antlrgen

package
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 4, 2026 License: Apache-2.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source
const (
	RelationalLexerSPACE                             = 1
	RelationalLexerCOMMENT_INPUT                     = 2
	RelationalLexerLINE_COMMENT                      = 3
	RelationalLexerADD                               = 4
	RelationalLexerALL                               = 5
	RelationalLexerALTER                             = 6
	RelationalLexerALWAYS                            = 7
	RelationalLexerANALYZE                           = 8
	RelationalLexerAND                               = 9
	RelationalLexerARRAY                             = 10
	RelationalLexerAS                                = 11
	RelationalLexerASC                               = 12
	RelationalLexerATTRIBUTES                        = 13
	RelationalLexerBEFORE                            = 14
	RelationalLexerBETWEEN                           = 15
	RelationalLexerBOTH                              = 16
	RelationalLexerBUCKETS                           = 17
	RelationalLexerBY                                = 18
	RelationalLexerCALL                              = 19
	RelationalLexerCALLED                            = 20
	RelationalLexerCASCADE                           = 21
	RelationalLexerCASE                              = 22
	RelationalLexerCAST                              = 23
	RelationalLexerCHANGE                            = 24
	RelationalLexerCHARACTER                         = 25
	RelationalLexerCHECK                             = 26
	RelationalLexerCOLLATE                           = 27
	RelationalLexerCOLUMN                            = 28
	RelationalLexerCONDITION                         = 29
	RelationalLexerCONSTRAINT                        = 30
	RelationalLexerCONTINUE                          = 31
	RelationalLexerCONVERT                           = 32
	RelationalLexerCREATE                            = 33
	RelationalLexerCROSS                             = 34
	RelationalLexerCURRENT                           = 35
	RelationalLexerCURRENT_USER                      = 36
	RelationalLexerCURSOR                            = 37
	RelationalLexerDATABASE                          = 38
	RelationalLexerDATABASES                         = 39
	RelationalLexerDECLARE                           = 40
	RelationalLexerDEEP                              = 41
	RelationalLexerDEFAULT                           = 42
	RelationalLexerDELAYED                           = 43
	RelationalLexerDELETE                            = 44
	RelationalLexerDESC                              = 45
	RelationalLexerDESCRIBE                          = 46
	RelationalLexerDETERMINISTIC                     = 47
	RelationalLexerDIAGNOSTICS                       = 48
	RelationalLexerDISPATCH                          = 49
	RelationalLexerDISTINCT                          = 50
	RelationalLexerDISTINCTROW                       = 51
	RelationalLexerDROP                              = 52
	RelationalLexerEACH                              = 53
	RelationalLexerELSE                              = 54
	RelationalLexerELSEIF                            = 55
	RelationalLexerEMPTY                             = 56
	RelationalLexerENCLOSED                          = 57
	RelationalLexerESCAPED                           = 58
	RelationalLexerEXCEPT                            = 59
	RelationalLexerEXISTS                            = 60
	RelationalLexerEXIT                              = 61
	RelationalLexerEXPLAIN                           = 62
	RelationalLexerFALSE                             = 63
	RelationalLexerFETCH                             = 64
	RelationalLexerFOR                               = 65
	RelationalLexerFORCE                             = 66
	RelationalLexerFOREIGN                           = 67
	RelationalLexerFROM                              = 68
	RelationalLexerFULLTEXT                          = 69
	RelationalLexerGENERATED                         = 70
	RelationalLexerGET                               = 71
	RelationalLexerGRANT                             = 72
	RelationalLexerGROUP                             = 73
	RelationalLexerHAVING                            = 74
	RelationalLexerHNSW                              = 75
	RelationalLexerGUARDIANN                         = 76
	RelationalLexerSPFRESH                           = 77
	RelationalLexerHIGH_PRIORITY                     = 78
	RelationalLexerHISTOGRAM                         = 79
	RelationalLexerIF                                = 80
	RelationalLexerIGNORE                            = 81
	RelationalLexerIGNORED                           = 82
	RelationalLexerIN                                = 83
	RelationalLexerINDEX                             = 84
	RelationalLexerINFILE                            = 85
	RelationalLexerINNER                             = 86
	RelationalLexerINOUT                             = 87
	RelationalLexerINPUT                             = 88
	RelationalLexerINSERT                            = 89
	RelationalLexerINTERVAL                          = 90
	RelationalLexerINTO                              = 91
	RelationalLexerIS                                = 92
	RelationalLexerITERATE                           = 93
	RelationalLexerJOIN                              = 94
	RelationalLexerKEY                               = 95
	RelationalLexerKEYS                              = 96
	RelationalLexerKILL                              = 97
	RelationalLexerLEADING                           = 98
	RelationalLexerLEAVE                             = 99
	RelationalLexerLEFT                              = 100
	RelationalLexerLIKE                              = 101
	RelationalLexerLIMIT                             = 102
	RelationalLexerLINEAR                            = 103
	RelationalLexerLINES                             = 104
	RelationalLexerLOAD                              = 105
	RelationalLexerLOCK                              = 106
	RelationalLexerLOOP                              = 107
	RelationalLexerLOW_PRIORITY                      = 108
	RelationalLexerMASTER_BIND                       = 109
	RelationalLexerMASTER_SSL_VERIFY_SERVER_CERT     = 110
	RelationalLexerMATCH                             = 111
	RelationalLexerMAXVALUE                          = 112
	RelationalLexerMODIFIES                          = 113
	RelationalLexerNATURAL                           = 114
	RelationalLexerNOT                               = 115
	RelationalLexerNO_WRITE_TO_BINLOG                = 116
	RelationalLexerNULL_LITERAL                      = 117
	RelationalLexerNUMBER                            = 118
	RelationalLexerOFF                               = 119
	RelationalLexerON                                = 120
	RelationalLexerOPTIMIZE                          = 121
	RelationalLexerOPTION                            = 122
	RelationalLexerOPTIONAL                          = 123
	RelationalLexerOPTIONALLY                        = 124
	RelationalLexerOR                                = 125
	RelationalLexerORDER                             = 126
	RelationalLexerOUT                               = 127
	RelationalLexerOVER                              = 128
	RelationalLexerOUTER                             = 129
	RelationalLexerOUTFILE                           = 130
	RelationalLexerPARTITION                         = 131
	RelationalLexerPLAN                              = 132
	RelationalLexerPRIMARY                           = 133
	RelationalLexerPROCEDURE                         = 134
	RelationalLexerPURGE                             = 135
	RelationalLexerQUALIFY                           = 136
	RelationalLexerREAD                              = 137
	RelationalLexerREADS                             = 138
	RelationalLexerRECURSIVE                         = 139
	RelationalLexerREFERENCES                        = 140
	RelationalLexerREGEXP                            = 141
	RelationalLexerRELEASE                           = 142
	RelationalLexerRENAME                            = 143
	RelationalLexerREPEAT                            = 144
	RelationalLexerREPLACE                           = 145
	RelationalLexerREQUIRE                           = 146
	RelationalLexerRESIGNAL                          = 147
	RelationalLexerRESTRICT                          = 148
	RelationalLexerRETAIN                            = 149
	RelationalLexerRETURN                            = 150
	RelationalLexerREVOKE                            = 151
	RelationalLexerRIGHT                             = 152
	RelationalLexerRLIKE                             = 153
	RelationalLexerSCHEMA                            = 154
	RelationalLexerSCHEMAS                           = 155
	RelationalLexerSELECT                            = 156
	RelationalLexerSET                               = 157
	RelationalLexerSEPARATOR                         = 158
	RelationalLexerSHOW                              = 159
	RelationalLexerSIGNAL                            = 160
	RelationalLexerSPATIAL                           = 161
	RelationalLexerSQL                               = 162
	RelationalLexerSQLEXCEPTION                      = 163
	RelationalLexerSQLSTATE                          = 164
	RelationalLexerSQLWARNING                        = 165
	RelationalLexerSQL_BIG_RESULT                    = 166
	RelationalLexerSQL_CALC_FOUND_ROWS               = 167
	RelationalLexerSQL_SMALL_RESULT                  = 168
	RelationalLexerSSL                               = 169
	RelationalLexerSTATIC                            = 170
	RelationalLexerSTACKED                           = 171
	RelationalLexerSTARTING                          = 172
	RelationalLexerSTRAIGHT_JOIN                     = 173
	RelationalLexerTABLE                             = 174
	RelationalLexerTERMINATED                        = 175
	RelationalLexerTHEN                              = 176
	RelationalLexerTO                                = 177
	RelationalLexerTRAILING                          = 178
	RelationalLexerTRAVERSAL                         = 179
	RelationalLexerTRIGGER                           = 180
	RelationalLexerTRUE                              = 181
	RelationalLexerUNDO                              = 182
	RelationalLexerUNION                             = 183
	RelationalLexerUNIQUE                            = 184
	RelationalLexerUNLOCK                            = 185
	RelationalLexerUNSIGNED                          = 186
	RelationalLexerUPDATE                            = 187
	RelationalLexerUSAGE                             = 188
	RelationalLexerUSE                               = 189
	RelationalLexerUSING                             = 190
	RelationalLexerVALUES                            = 191
	RelationalLexerWHEN                              = 192
	RelationalLexerWHERE                             = 193
	RelationalLexerWHILE                             = 194
	RelationalLexerWITH                              = 195
	RelationalLexerCONTINUATION                      = 196
	RelationalLexerWRITE                             = 197
	RelationalLexerXOR                               = 198
	RelationalLexerZEROFILL                          = 199
	RelationalLexerTINYINT                           = 200
	RelationalLexerSMALLINT                          = 201
	RelationalLexerMEDIUMINT                         = 202
	RelationalLexerMIDDLEINT                         = 203
	RelationalLexerINT                               = 204
	RelationalLexerINT1                              = 205
	RelationalLexerINT2                              = 206
	RelationalLexerINT3                              = 207
	RelationalLexerINT4                              = 208
	RelationalLexerINT8                              = 209
	RelationalLexerINT32                             = 210
	RelationalLexerINT64                             = 211
	RelationalLexerINTEGER                           = 212
	RelationalLexerBIGINT                            = 213
	RelationalLexerBYTES                             = 214
	RelationalLexerREAL                              = 215
	RelationalLexerDOUBLE                            = 216
	RelationalLexerPRECISION                         = 217
	RelationalLexerFLOAT                             = 218
	RelationalLexerFLOAT4                            = 219
	RelationalLexerFLOAT8                            = 220
	RelationalLexerDECIMAL                           = 221
	RelationalLexerDEC                               = 222
	RelationalLexerNUMERIC                           = 223
	RelationalLexerDATE                              = 224
	RelationalLexerTIME                              = 225
	RelationalLexerTIMESTAMP                         = 226
	RelationalLexerDATETIME                          = 227
	RelationalLexerYEAR                              = 228
	RelationalLexerCHAR                              = 229
	RelationalLexerVARCHAR                           = 230
	RelationalLexerNVARCHAR                          = 231
	RelationalLexerNATIONAL                          = 232
	RelationalLexerBINARY                            = 233
	RelationalLexerVARBINARY                         = 234
	RelationalLexerTINYBLOB                          = 235
	RelationalLexerBLOB                              = 236
	RelationalLexerMEDIUMBLOB                        = 237
	RelationalLexerLONG                              = 238
	RelationalLexerLONGBLOB                          = 239
	RelationalLexerTINYTEXT                          = 240
	RelationalLexerTEXT                              = 241
	RelationalLexerMEDIUMTEXT                        = 242
	RelationalLexerLONGTEXT                          = 243
	RelationalLexerENUM                              = 244
	RelationalLexerVARYING                           = 245
	RelationalLexerSERIAL                            = 246
	RelationalLexerMESSAGE                           = 247
	RelationalLexerYEAR_MONTH                        = 248
	RelationalLexerDAY_HOUR                          = 249
	RelationalLexerDAY_MINUTE                        = 250
	RelationalLexerDAY_SECOND                        = 251
	RelationalLexerHOUR_MINUTE                       = 252
	RelationalLexerHOUR_SECOND                       = 253
	RelationalLexerMINUTE_SECOND                     = 254
	RelationalLexerSECOND_MICROSECOND                = 255
	RelationalLexerMINUTE_MICROSECOND                = 256
	RelationalLexerHOUR_MICROSECOND                  = 257
	RelationalLexerDAY_MICROSECOND                   = 258
	RelationalLexerJSON_ARRAY                        = 259
	RelationalLexerJSON_OBJECT                       = 260
	RelationalLexerJSON_QUOTE                        = 261
	RelationalLexerJSON_CONTAINS                     = 262
	RelationalLexerJSON_CONTAINS_PATH                = 263
	RelationalLexerJSON_EXTRACT                      = 264
	RelationalLexerJSON_KEYS                         = 265
	RelationalLexerJSON_OVERLAPS                     = 266
	RelationalLexerJSON_SEARCH                       = 267
	RelationalLexerJSON_VALUE                        = 268
	RelationalLexerJSON_ARRAY_APPEND                 = 269
	RelationalLexerJSON_ARRAY_INSERT                 = 270
	RelationalLexerJSON_INSERT                       = 271
	RelationalLexerJSON_MERGE                        = 272
	RelationalLexerJSON_MERGE_PATCH                  = 273
	RelationalLexerJSON_MERGE_PRESERVE               = 274
	RelationalLexerJSON_REMOVE                       = 275
	RelationalLexerJSON_REPLACE                      = 276
	RelationalLexerJSON_SET                          = 277
	RelationalLexerJSON_UNQUOTE                      = 278
	RelationalLexerJSON_DEPTH                        = 279
	RelationalLexerJSON_LENGTH                       = 280
	RelationalLexerJSON_TYPE                         = 281
	RelationalLexerJSON_VALID                        = 282
	RelationalLexerJSON_TABLE                        = 283
	RelationalLexerJSON_SCHEMA_VALID                 = 284
	RelationalLexerJSON_SCHEMA_VALIDATION_REPORT     = 285
	RelationalLexerJSON_PRETTY                       = 286
	RelationalLexerJSON_STORAGE_FREE                 = 287
	RelationalLexerJSON_STORAGE_SIZE                 = 288
	RelationalLexerJSON_ARRAYAGG                     = 289
	RelationalLexerJSON_OBJECTAGG                    = 290
	RelationalLexerARRAY_AGG                         = 291
	RelationalLexerAVG                               = 292
	RelationalLexerBIT_AND                           = 293
	RelationalLexerBITMAP_BIT_POSITION               = 294
	RelationalLexerBITMAP_BUCKET_OFFSET              = 295
	RelationalLexerBITMAP_BUCKET_NUMBER              = 296
	RelationalLexerBITMAP_CONSTRUCT_AGG              = 297
	RelationalLexerBIT_OR                            = 298
	RelationalLexerBIT_XOR                           = 299
	RelationalLexerCOUNT                             = 300
	RelationalLexerCUME_DIST                         = 301
	RelationalLexerDENSE_RANK                        = 302
	RelationalLexerFIRST_VALUE                       = 303
	RelationalLexerGROUP_CONCAT                      = 304
	RelationalLexerLAG                               = 305
	RelationalLexerLAST_VALUE                        = 306
	RelationalLexerLEAD                              = 307
	RelationalLexerMAX                               = 308
	RelationalLexerMAX_EVER                          = 309
	RelationalLexerMIN                               = 310
	RelationalLexerMIN_EVER                          = 311
	RelationalLexerNTILE                             = 312
	RelationalLexerNTH_VALUE                         = 313
	RelationalLexerPERCENT_RANK                      = 314
	RelationalLexerRANK                              = 315
	RelationalLexerROW_NUMBER                        = 316
	RelationalLexerSTD                               = 317
	RelationalLexerSTDDEV                            = 318
	RelationalLexerSTDDEV_POP                        = 319
	RelationalLexerSTDDEV_SAMP                       = 320
	RelationalLexerSUM                               = 321
	RelationalLexerVAR_POP                           = 322
	RelationalLexerVAR_SAMP                          = 323
	RelationalLexerVARIANCE                          = 324
	RelationalLexerCURRENT_DATE                      = 325
	RelationalLexerCURRENT_TIME                      = 326
	RelationalLexerCURRENT_TIMESTAMP                 = 327
	RelationalLexerLOCALTIME                         = 328
	RelationalLexerCURDATE                           = 329
	RelationalLexerCURTIME                           = 330
	RelationalLexerDATE_ADD                          = 331
	RelationalLexerDATE_SUB                          = 332
	RelationalLexerEXTRACT                           = 333
	RelationalLexerLOCALTIMESTAMP                    = 334
	RelationalLexerNOW                               = 335
	RelationalLexerPOSITION                          = 336
	RelationalLexerSUBSTR                            = 337
	RelationalLexerSUBSTRING                         = 338
	RelationalLexerSYSDATE                           = 339
	RelationalLexerTRIM                              = 340
	RelationalLexerUTC_DATE                          = 341
	RelationalLexerUTC_TIME                          = 342
	RelationalLexerUTC_TIMESTAMP                     = 343
	RelationalLexerJAVA_CALL                         = 344
	RelationalLexerACCOUNT                           = 345
	RelationalLexerACTION                            = 346
	RelationalLexerAFTER                             = 347
	RelationalLexerAGGREGATE                         = 348
	RelationalLexerALGORITHM                         = 349
	RelationalLexerANY                               = 350
	RelationalLexerAT                                = 351
	RelationalLexerAUTHORS                           = 352
	RelationalLexerAUTOCOMMIT                        = 353
	RelationalLexerAUTOEXTEND_SIZE                   = 354
	RelationalLexerAUTO_INCREMENT                    = 355
	RelationalLexerAVG_ROW_LENGTH                    = 356
	RelationalLexerBEGIN                             = 357
	RelationalLexerBINLOG                            = 358
	RelationalLexerBIT                               = 359
	RelationalLexerBLOCK                             = 360
	RelationalLexerBOOL                              = 361
	RelationalLexerBOOLEAN                           = 362
	RelationalLexerBTREE                             = 363
	RelationalLexerCACHE                             = 364
	RelationalLexerCASCADED                          = 365
	RelationalLexerCHAIN                             = 366
	RelationalLexerCHANGED                           = 367
	RelationalLexerCHANNEL                           = 368
	RelationalLexerCHECKSUM                          = 369
	RelationalLexerCOMPILED                          = 370
	RelationalLexerPAGE_CHECKSUM                     = 371
	RelationalLexerCIPHER                            = 372
	RelationalLexerCLASS_ORIGIN                      = 373
	RelationalLexerCLIENT                            = 374
	RelationalLexerCLOSE                             = 375
	RelationalLexerCLUSTERING                        = 376
	RelationalLexerCOALESCE                          = 377
	RelationalLexerCODE                              = 378
	RelationalLexerCOLUMNS                           = 379
	RelationalLexerCOLUMN_FORMAT                     = 380
	RelationalLexerCOLUMN_NAME                       = 381
	RelationalLexerCOMMENT                           = 382
	RelationalLexerCOMMIT                            = 383
	RelationalLexerCOMPACT                           = 384
	RelationalLexerCOMPLETION                        = 385
	RelationalLexerCOMPRESSED                        = 386
	RelationalLexerCOMPRESSION                       = 387
	RelationalLexerCONCURRENT                        = 388
	RelationalLexerCONNECT                           = 389
	RelationalLexerCONNECTION                        = 390
	RelationalLexerCONSISTENT                        = 391
	RelationalLexerCONSTRAINT_CATALOG                = 392
	RelationalLexerCONSTRAINT_SCHEMA                 = 393
	RelationalLexerCONSTRAINT_NAME                   = 394
	RelationalLexerCONTAINS                          = 395
	RelationalLexerCONTEXT                           = 396
	RelationalLexerCONTRIBUTORS                      = 397
	RelationalLexerCOPY                              = 398
	RelationalLexerCPU                               = 399
	RelationalLexerCURSOR_NAME                       = 400
	RelationalLexerDATA                              = 401
	RelationalLexerDATAFILE                          = 402
	RelationalLexerDEALLOCATE                        = 403
	RelationalLexerDEFAULT_AUTH                      = 404
	RelationalLexerDEFINER                           = 405
	RelationalLexerDELAY_KEY_WRITE                   = 406
	RelationalLexerDES_KEY_FILE                      = 407
	RelationalLexerDIRECTORY                         = 408
	RelationalLexerDISABLE                           = 409
	RelationalLexerDISCARD                           = 410
	RelationalLexerDISK                              = 411
	RelationalLexerDO                                = 412
	RelationalLexerDUMPFILE                          = 413
	RelationalLexerDUPLICATE                         = 414
	RelationalLexerDYNAMIC                           = 415
	RelationalLexerENABLE                            = 416
	RelationalLexerENCRYPTION                        = 417
	RelationalLexerEND                               = 418
	RelationalLexerENDS                              = 419
	RelationalLexerENGINE                            = 420
	RelationalLexerENGINES                           = 421
	RelationalLexerERROR                             = 422
	RelationalLexerERRORS                            = 423
	RelationalLexerESCAPE                            = 424
	RelationalLexerEVEN                              = 425
	RelationalLexerEVENT                             = 426
	RelationalLexerEVENTS                            = 427
	RelationalLexerEVERY                             = 428
	RelationalLexerEXCHANGE                          = 429
	RelationalLexerEXCLUSIVE                         = 430
	RelationalLexerEXPIRE                            = 431
	RelationalLexerEXPORT                            = 432
	RelationalLexerEXTENDED                          = 433
	RelationalLexerEXTENT_SIZE                       = 434
	RelationalLexerFAST                              = 435
	RelationalLexerFAULTS                            = 436
	RelationalLexerFIELDS                            = 437
	RelationalLexerFILE_BLOCK_SIZE                   = 438
	RelationalLexerFILTER                            = 439
	RelationalLexerFIRST                             = 440
	RelationalLexerFIXED                             = 441
	RelationalLexerFLUSH                             = 442
	RelationalLexerFOLLOWING                         = 443
	RelationalLexerFOLLOWS                           = 444
	RelationalLexerFOUND                             = 445
	RelationalLexerFULL                              = 446
	RelationalLexerFUNCTION                          = 447
	RelationalLexerGENERAL                           = 448
	RelationalLexerGLOBAL                            = 449
	RelationalLexerGRANTS                            = 450
	RelationalLexerGROUP_REPLICATION                 = 451
	RelationalLexerHALF                              = 452
	RelationalLexerHANDLER                           = 453
	RelationalLexerHAS                               = 454
	RelationalLexerHASH                              = 455
	RelationalLexerHELP                              = 456
	RelationalLexerHOST                              = 457
	RelationalLexerHOSTS                             = 458
	RelationalLexerIDENTIFIED                        = 459
	RelationalLexerIGNORE_SERVER_IDS                 = 460
	RelationalLexerIMPORT                            = 461
	RelationalLexerINCLUDE                           = 462
	RelationalLexerINDEXES                           = 463
	RelationalLexerINITIAL_SIZE                      = 464
	RelationalLexerINPLACE                           = 465
	RelationalLexerINSERT_METHOD                     = 466
	RelationalLexerINSTALL                           = 467
	RelationalLexerINSTANCE                          = 468
	RelationalLexerINSTANT                           = 469
	RelationalLexerINVISIBLE                         = 470
	RelationalLexerINVOKER                           = 471
	RelationalLexerIO                                = 472
	RelationalLexerIO_THREAD                         = 473
	RelationalLexerIPC                               = 474
	RelationalLexerISOLATION                         = 475
	RelationalLexerISSUER                            = 476
	RelationalLexerJAVA                              = 477
	RelationalLexerJSON                              = 478
	RelationalLexerKEY_BLOCK_SIZE                    = 479
	RelationalLexerLANGUAGE                          = 480
	RelationalLexerLAST                              = 481
	RelationalLexerLEAVES                            = 482
	RelationalLexerLESS                              = 483
	RelationalLexerLEVEL                             = 484
	RelationalLexerLEVEL_ORDER                       = 485
	RelationalLexerLIST                              = 486
	RelationalLexerLOCAL                             = 487
	RelationalLexerLOGFILE                           = 488
	RelationalLexerLOGS                              = 489
	RelationalLexerMASTER                            = 490
	RelationalLexerMASTER_AUTO_POSITION              = 491
	RelationalLexerMASTER_CONNECT_RETRY              = 492
	RelationalLexerMASTER_DELAY                      = 493
	RelationalLexerMASTER_HEARTBEAT_PERIOD           = 494
	RelationalLexerMASTER_HOST                       = 495
	RelationalLexerMASTER_LOG_FILE                   = 496
	RelationalLexerMASTER_LOG_POS                    = 497
	RelationalLexerMASTER_PASSWORD                   = 498
	RelationalLexerMASTER_PORT                       = 499
	RelationalLexerMASTER_RETRY_COUNT                = 500
	RelationalLexerMASTER_SSL                        = 501
	RelationalLexerMASTER_SSL_CA                     = 502
	RelationalLexerMASTER_SSL_CAPATH                 = 503
	RelationalLexerMASTER_SSL_CERT                   = 504
	RelationalLexerMASTER_SSL_CIPHER                 = 505
	RelationalLexerMASTER_SSL_CRL                    = 506
	RelationalLexerMASTER_SSL_CRLPATH                = 507
	RelationalLexerMASTER_SSL_KEY                    = 508
	RelationalLexerMASTER_TLS_VERSION                = 509
	RelationalLexerMASTER_USER                       = 510
	RelationalLexerMAX_CONNECTIONS_PER_HOUR          = 511
	RelationalLexerMAX_QUERIES_PER_HOUR              = 512
	RelationalLexerMAX_ROWS                          = 513
	RelationalLexerMAX_SIZE                          = 514
	RelationalLexerMAX_UPDATES_PER_HOUR              = 515
	RelationalLexerMAX_USER_CONNECTIONS              = 516
	RelationalLexerMEDIUM                            = 517
	RelationalLexerMEMBER                            = 518
	RelationalLexerMERGE                             = 519
	RelationalLexerMESSAGE_TEXT                      = 520
	RelationalLexerMID                               = 521
	RelationalLexerMIGRATE                           = 522
	RelationalLexerMIN_ROWS                          = 523
	RelationalLexerMODE                              = 524
	RelationalLexerMODIFY                            = 525
	RelationalLexerMUTEX                             = 526
	RelationalLexerMYSQL                             = 527
	RelationalLexerMYSQL_ERRNO                       = 528
	RelationalLexerNAME                              = 529
	RelationalLexerNAMES                             = 530
	RelationalLexerNCHAR                             = 531
	RelationalLexerNEVER                             = 532
	RelationalLexerNEXT                              = 533
	RelationalLexerNO                                = 534
	RelationalLexerNOCOPY                            = 535
	RelationalLexerNOWAIT                            = 536
	RelationalLexerNODEGROUP                         = 537
	RelationalLexerNONE                              = 538
	RelationalLexerNOCACHE                           = 539
	RelationalLexerNULLS                             = 540
	RelationalLexerODBC                              = 541
	RelationalLexerOFFLINE                           = 542
	RelationalLexerOFFSET                            = 543
	RelationalLexerOF                                = 544
	RelationalLexerOJ                                = 545
	RelationalLexerOLD_PASSWORD                      = 546
	RelationalLexerONE                               = 547
	RelationalLexerONLINE                            = 548
	RelationalLexerONLY                              = 549
	RelationalLexerOPEN                              = 550
	RelationalLexerOPTIMIZER_COSTS                   = 551
	RelationalLexerOPTIONS                           = 552
	RelationalLexerOWNER                             = 553
	RelationalLexerPACK_KEYS                         = 554
	RelationalLexerPAGE                              = 555
	RelationalLexerPARAMETER                         = 556
	RelationalLexerPARSER                            = 557
	RelationalLexerPARTIAL                           = 558
	RelationalLexerPARTITIONING                      = 559
	RelationalLexerPARTITIONS                        = 560
	RelationalLexerPASSWORD                          = 561
	RelationalLexerPHASE                             = 562
	RelationalLexerPLUGIN                            = 563
	RelationalLexerPLUGIN_DIR                        = 564
	RelationalLexerPLUGINS                           = 565
	RelationalLexerPORT                              = 566
	RelationalLexerPOST_ORDER                        = 567
	RelationalLexerPRECEDES                          = 568
	RelationalLexerPRECEDING                         = 569
	RelationalLexerPREFIX                            = 570
	RelationalLexerPRE_ORDER                         = 571
	RelationalLexerPREPARE                           = 572
	RelationalLexerPRESERVE                          = 573
	RelationalLexerPREV                              = 574
	RelationalLexerPROCESSLIST                       = 575
	RelationalLexerPROFILE                           = 576
	RelationalLexerPROFILES                          = 577
	RelationalLexerPROXY                             = 578
	RelationalLexerQUERY                             = 579
	RelationalLexerQUICK                             = 580
	RelationalLexerREBUILD                           = 581
	RelationalLexerRECOVER                           = 582
	RelationalLexerREDO_BUFFER_SIZE                  = 583
	RelationalLexerREDUNDANT                         = 584
	RelationalLexerRELAY                             = 585
	RelationalLexerRELAY_LOG_FILE                    = 586
	RelationalLexerRELAY_LOG_POS                     = 587
	RelationalLexerRELAYLOG                          = 588
	RelationalLexerREMOVE                            = 589
	RelationalLexerREORGANIZE                        = 590
	RelationalLexerREPAIR                            = 591
	RelationalLexerREPEATED                          = 592
	RelationalLexerREPLICATE_DO_DB                   = 593
	RelationalLexerREPLICATE_DO_TABLE                = 594
	RelationalLexerREPLICATE_IGNORE_DB               = 595
	RelationalLexerREPLICATE_IGNORE_TABLE            = 596
	RelationalLexerREPLICATE_REWRITE_DB              = 597
	RelationalLexerREPLICATE_WILD_DO_TABLE           = 598
	RelationalLexerREPLICATE_WILD_IGNORE_TABLE       = 599
	RelationalLexerREPLICATION                       = 600
	RelationalLexerRESET                             = 601
	RelationalLexerRESPECT                           = 602
	RelationalLexerRESUME                            = 603
	RelationalLexerRETURNED_SQLSTATE                 = 604
	RelationalLexerRETURNING                         = 605
	RelationalLexerRETURNS                           = 606
	RelationalLexerROLE                              = 607
	RelationalLexerROLLBACK                          = 608
	RelationalLexerROLLUP                            = 609
	RelationalLexerROTATE                            = 610
	RelationalLexerROW                               = 611
	RelationalLexerROWS                              = 612
	RelationalLexerROW_FORMAT                        = 613
	RelationalLexerRTREE                             = 614
	RelationalLexerSAVEPOINT                         = 615
	RelationalLexerSCHEDULE                          = 616
	RelationalLexerSECURITY                          = 617
	RelationalLexerSERVER                            = 618
	RelationalLexerSESSION                           = 619
	RelationalLexerSHARE                             = 620
	RelationalLexerSHARED                            = 621
	RelationalLexerSIGNED                            = 622
	RelationalLexerSIMPLE                            = 623
	RelationalLexerSINGLE                            = 624
	RelationalLexerSLAVE                             = 625
	RelationalLexerSLOW                              = 626
	RelationalLexerSNAPSHOT                          = 627
	RelationalLexerSOCKET                            = 628
	RelationalLexerSOME                              = 629
	RelationalLexerSONAME                            = 630
	RelationalLexerSOUNDS                            = 631
	RelationalLexerSOURCE                            = 632
	RelationalLexerSQL_AFTER_GTIDS                   = 633
	RelationalLexerSQL_AFTER_MTS_GAPS                = 634
	RelationalLexerSQL_BEFORE_GTIDS                  = 635
	RelationalLexerSQL_BUFFER_RESULT                 = 636
	RelationalLexerSQL_THREAD                        = 637
	RelationalLexerSTART                             = 638
	RelationalLexerSTARTS                            = 639
	RelationalLexerSTATEMENT                         = 640
	RelationalLexerSTATS_AUTO_RECALC                 = 641
	RelationalLexerSTATS_PERSISTENT                  = 642
	RelationalLexerSTATS_SAMPLE_PAGES                = 643
	RelationalLexerSTATUS                            = 644
	RelationalLexerSTOP                              = 645
	RelationalLexerSTORAGE                           = 646
	RelationalLexerSTORED                            = 647
	RelationalLexerSTRING                            = 648
	RelationalLexerSTRUCT                            = 649
	RelationalLexerSTYLE                             = 650
	RelationalLexerSUBCLASS_ORIGIN                   = 651
	RelationalLexerSUBJECT                           = 652
	RelationalLexerSUBPARTITION                      = 653
	RelationalLexerSUBPARTITIONS                     = 654
	RelationalLexerSUSPEND                           = 655
	RelationalLexerSWAPS                             = 656
	RelationalLexerSWITCHES                          = 657
	RelationalLexerTABLE_NAME                        = 658
	RelationalLexerTABLESPACE                        = 659
	RelationalLexerTABLE_TYPE                        = 660
	RelationalLexerTEMPLATE                          = 661
	RelationalLexerTEMPLATES                         = 662
	RelationalLexerTEMPORARY                         = 663
	RelationalLexerTEMPTABLE                         = 664
	RelationalLexerTHAN                              = 665
	RelationalLexerTRADITIONAL                       = 666
	RelationalLexerTRANSACTION                       = 667
	RelationalLexerTRANSACTIONAL                     = 668
	RelationalLexerTRIGGERS                          = 669
	RelationalLexerTRUNCATE                          = 670
	RelationalLexerTYPE                              = 671
	RelationalLexerUNBOUNDED                         = 672
	RelationalLexerUNDEFINED                         = 673
	RelationalLexerUNDOFILE                          = 674
	RelationalLexerUNDO_BUFFER_SIZE                  = 675
	RelationalLexerUNINSTALL                         = 676
	RelationalLexerUNKNOWN                           = 677
	RelationalLexerUNTIL                             = 678
	RelationalLexerUPGRADE                           = 679
	RelationalLexerUSER                              = 680
	RelationalLexerUSE_FRM                           = 681
	RelationalLexerUSER_RESOURCES                    = 682
	RelationalLexerVALIDATION                        = 683
	RelationalLexerVALUE                             = 684
	RelationalLexerVARIABLES                         = 685
	RelationalLexerVECTOR                            = 686
	RelationalLexerVIEW                              = 687
	RelationalLexerVIRTUAL                           = 688
	RelationalLexerVISIBLE                           = 689
	RelationalLexerWAIT                              = 690
	RelationalLexerWARNINGS                          = 691
	RelationalLexerWINDOW                            = 692
	RelationalLexerLEGACY_EXTREMUM_EVER              = 693
	RelationalLexerWITHOUT                           = 694
	RelationalLexerWORK                              = 695
	RelationalLexerWRAPPER                           = 696
	RelationalLexerX509                              = 697
	RelationalLexerXA                                = 698
	RelationalLexerXML                               = 699
	RelationalLexerYES                               = 700
	RelationalLexerEUR                               = 701
	RelationalLexerUSA                               = 702
	RelationalLexerJIS                               = 703
	RelationalLexerISO                               = 704
	RelationalLexerINTERNAL                          = 705
	RelationalLexerQUARTER                           = 706
	RelationalLexerMONTH                             = 707
	RelationalLexerDAY                               = 708
	RelationalLexerHOUR                              = 709
	RelationalLexerMINUTE                            = 710
	RelationalLexerWEEK                              = 711
	RelationalLexerSECOND                            = 712
	RelationalLexerMICROSECOND                       = 713
	RelationalLexerTABLES                            = 714
	RelationalLexerROUTINE                           = 715
	RelationalLexerEXECUTE                           = 716
	RelationalLexerFILE                              = 717
	RelationalLexerPROCESS                           = 718
	RelationalLexerRELOAD                            = 719
	RelationalLexerSHUTDOWN                          = 720
	RelationalLexerSUPER                             = 721
	RelationalLexerPRIVILEGES                        = 722
	RelationalLexerAPPLICATION_PASSWORD_ADMIN        = 723
	RelationalLexerAUDIT_ADMIN                       = 724
	RelationalLexerBACKUP_ADMIN                      = 725
	RelationalLexerBINLOG_ADMIN                      = 726
	RelationalLexerBINLOG_ENCRYPTION_ADMIN           = 727
	RelationalLexerCLONE_ADMIN                       = 728
	RelationalLexerCONNECTION_ADMIN                  = 729
	RelationalLexerENCRYPTION_KEY_ADMIN              = 730
	RelationalLexerFIREWALL_ADMIN                    = 731
	RelationalLexerFIREWALL_USER                     = 732
	RelationalLexerFLUSH_OPTIMIZER_COSTS             = 733
	RelationalLexerFLUSH_STATUS                      = 734
	RelationalLexerFLUSH_TABLES                      = 735
	RelationalLexerFLUSH_USER_RESOURCES              = 736
	RelationalLexerADMIN                             = 737
	RelationalLexerGROUP_REPLICATION_ADMIN           = 738
	RelationalLexerINNODB_REDO_LOG_ARCHIVE           = 739
	RelationalLexerINNODB_REDO_LOG_ENABLE            = 740
	RelationalLexerNDB_STORED_USER                   = 741
	RelationalLexerPERSIST_RO_VARIABLES_ADMIN        = 742
	RelationalLexerREPLICATION_APPLIER               = 743
	RelationalLexerREPLICATION_SLAVE_ADMIN           = 744
	RelationalLexerRESOURCE_GROUP_ADMIN              = 745
	RelationalLexerRESOURCE_GROUP_USER               = 746
	RelationalLexerROLE_ADMIN                        = 747
	RelationalLexerSERVICE_CONNECTION_ADMIN          = 748
	RelationalLexerSESSION_VARIABLES_ADMIN           = 749
	RelationalLexerSET_USER_ID                       = 750
	RelationalLexerSHOW_ROUTINE                      = 751
	RelationalLexerSYSTEM_VARIABLES_ADMIN            = 752
	RelationalLexerTABLE_ENCRYPTION_ADMIN            = 753
	RelationalLexerVERSION_TOKEN_ADMIN               = 754
	RelationalLexerXA_RECOVER_ADMIN                  = 755
	RelationalLexerARMSCII8                          = 756
	RelationalLexerASCII                             = 757
	RelationalLexerBIG5                              = 758
	RelationalLexerCP1250                            = 759
	RelationalLexerCP1251                            = 760
	RelationalLexerCP1256                            = 761
	RelationalLexerCP1257                            = 762
	RelationalLexerCP850                             = 763
	RelationalLexerCP852                             = 764
	RelationalLexerCP866                             = 765
	RelationalLexerCP932                             = 766
	RelationalLexerDEC8                              = 767
	RelationalLexerEUCJPMS                           = 768
	RelationalLexerEUCKR                             = 769
	RelationalLexerGB18030                           = 770
	RelationalLexerGB2312                            = 771
	RelationalLexerGBK                               = 772
	RelationalLexerGEOSTD8                           = 773
	RelationalLexerGREEK                             = 774
	RelationalLexerHEBREW                            = 775
	RelationalLexerHP8                               = 776
	RelationalLexerKEYBCS2                           = 777
	RelationalLexerKOI8R                             = 778
	RelationalLexerKOI8U                             = 779
	RelationalLexerLATIN1                            = 780
	RelationalLexerLATIN2                            = 781
	RelationalLexerLATIN5                            = 782
	RelationalLexerLATIN7                            = 783
	RelationalLexerMACCE                             = 784
	RelationalLexerMACROMAN                          = 785
	RelationalLexerSJIS                              = 786
	RelationalLexerSWE7                              = 787
	RelationalLexerTIS620                            = 788
	RelationalLexerUCS2                              = 789
	RelationalLexerUJIS                              = 790
	RelationalLexerUTF16                             = 791
	RelationalLexerUTF16LE                           = 792
	RelationalLexerUTF32                             = 793
	RelationalLexerUTF8                              = 794
	RelationalLexerUTF8MB3                           = 795
	RelationalLexerUTF8MB4                           = 796
	RelationalLexerARCHIVE                           = 797
	RelationalLexerBLACKHOLE                         = 798
	RelationalLexerCSV                               = 799
	RelationalLexerFEDERATED                         = 800
	RelationalLexerINNODB                            = 801
	RelationalLexerMEMORY                            = 802
	RelationalLexerMRG_MYISAM                        = 803
	RelationalLexerMYISAM                            = 804
	RelationalLexerNDB                               = 805
	RelationalLexerNDBCLUSTER                        = 806
	RelationalLexerPERFORMANCE_SCHEMA                = 807
	RelationalLexerTOKUDB                            = 808
	RelationalLexerREPEATABLE                        = 809
	RelationalLexerCOMMITTED                         = 810
	RelationalLexerUNCOMMITTED                       = 811
	RelationalLexerSERIALIZABLE                      = 812
	RelationalLexerGEOMETRYCOLLECTION                = 813
	RelationalLexerGEOMCOLLECTION                    = 814
	RelationalLexerGEOMETRY                          = 815
	RelationalLexerLINESTRING                        = 816
	RelationalLexerMULTILINESTRING                   = 817
	RelationalLexerMULTIPOINT                        = 818
	RelationalLexerMULTIPOLYGON                      = 819
	RelationalLexerPOINT                             = 820
	RelationalLexerPOLYGON                           = 821
	RelationalLexerABS                               = 822
	RelationalLexerACOS                              = 823
	RelationalLexerADDDATE                           = 824
	RelationalLexerADDTIME                           = 825
	RelationalLexerAES_DECRYPT                       = 826
	RelationalLexerAES_ENCRYPT                       = 827
	RelationalLexerAREA                              = 828
	RelationalLexerASBINARY                          = 829
	RelationalLexerASIN                              = 830
	RelationalLexerASTEXT                            = 831
	RelationalLexerASWKB                             = 832
	RelationalLexerASWKT                             = 833
	RelationalLexerASYMMETRIC_DECRYPT                = 834
	RelationalLexerASYMMETRIC_DERIVE                 = 835
	RelationalLexerASYMMETRIC_ENCRYPT                = 836
	RelationalLexerASYMMETRIC_SIGN                   = 837
	RelationalLexerASYMMETRIC_VERIFY                 = 838
	RelationalLexerATAN2                             = 839
	RelationalLexerATAN                              = 840
	RelationalLexerBENCHMARK                         = 841
	RelationalLexerBIN                               = 842
	RelationalLexerBIT_COUNT                         = 843
	RelationalLexerBIT_LENGTH                        = 844
	RelationalLexerBUFFER                            = 845
	RelationalLexerCATALOG_NAME                      = 846
	RelationalLexerCEIL                              = 847
	RelationalLexerCEILING                           = 848
	RelationalLexerCENTROID                          = 849
	RelationalLexerCHARACTER_LENGTH                  = 850
	RelationalLexerCHARSET                           = 851
	RelationalLexerCHAR_LENGTH                       = 852
	RelationalLexerCOERCIBILITY                      = 853
	RelationalLexerCOLLATION                         = 854
	RelationalLexerCOMPRESS                          = 855
	RelationalLexerCONCAT                            = 856
	RelationalLexerCONCAT_WS                         = 857
	RelationalLexerCONNECTION_ID                     = 858
	RelationalLexerCONV                              = 859
	RelationalLexerCONVERT_TZ                        = 860
	RelationalLexerCOS                               = 861
	RelationalLexerCOSINE_DISTANCE                   = 862
	RelationalLexerCOSINE_METRIC                     = 863
	RelationalLexerCOT                               = 864
	RelationalLexerCRC32                             = 865
	RelationalLexerCREATE_ASYMMETRIC_PRIV_KEY        = 866
	RelationalLexerCREATE_ASYMMETRIC_PUB_KEY         = 867
	RelationalLexerCREATE_DH_PARAMETERS              = 868
	RelationalLexerCREATE_DIGEST                     = 869
	RelationalLexerCROSSES                           = 870
	RelationalLexerDATEDIFF                          = 871
	RelationalLexerDATE_FORMAT                       = 872
	RelationalLexerDAYNAME                           = 873
	RelationalLexerDAYOFMONTH                        = 874
	RelationalLexerDAYOFWEEK                         = 875
	RelationalLexerDAYOFYEAR                         = 876
	RelationalLexerDECODE                            = 877
	RelationalLexerDEGREES                           = 878
	RelationalLexerDES_DECRYPT                       = 879
	RelationalLexerDES_ENCRYPT                       = 880
	RelationalLexerDIMENSION                         = 881
	RelationalLexerDISJOINT                          = 882
	RelationalLexerDOT_PRODUCT_DISTANCE              = 883
	RelationalLexerDOT_PRODUCT_METRIC                = 884
	RelationalLexerDRY                               = 885
	RelationalLexerEF_CONSTRUCTION                   = 886
	RelationalLexerEF_SEARCH                         = 887
	RelationalLexerELT                               = 888
	RelationalLexerENABLE_LONG_ROWS                  = 889
	RelationalLexerENCODE                            = 890
	RelationalLexerENCRYPT                           = 891
	RelationalLexerENDPOINT                          = 892
	RelationalLexerENGINE_ATTRIBUTE                  = 893
	RelationalLexerENVELOPE                          = 894
	RelationalLexerEQUALS                            = 895
	RelationalLexerEUCLIDEAN_DISTANCE                = 896
	RelationalLexerEUCLIDEAN_METRIC                  = 897
	RelationalLexerEUCLIDEAN_SQUARE_DISTANCE         = 898
	RelationalLexerEUCLIDEAN_SQUARE_METRIC           = 899
	RelationalLexerEXP                               = 900
	RelationalLexerEXPORT_SET                        = 901
	RelationalLexerEXTERIORRING                      = 902
	RelationalLexerEXTRACTVALUE                      = 903
	RelationalLexerFIELD                             = 904
	RelationalLexerFIND_IN_SET                       = 905
	RelationalLexerFLOOR                             = 906
	RelationalLexerFORMAT                            = 907
	RelationalLexerFOUND_ROWS                        = 908
	RelationalLexerFROM_BASE64                       = 909
	RelationalLexerFROM_DAYS                         = 910
	RelationalLexerFROM_UNIXTIME                     = 911
	RelationalLexerGEOMCOLLFROMTEXT                  = 912
	RelationalLexerGEOMCOLLFROMWKB                   = 913
	RelationalLexerGEOMETRYCOLLECTIONFROMTEXT        = 914
	RelationalLexerGEOMETRYCOLLECTIONFROMWKB         = 915
	RelationalLexerGEOMETRYFROMTEXT                  = 916
	RelationalLexerGEOMETRYFROMWKB                   = 917
	RelationalLexerGEOMETRYN                         = 918
	RelationalLexerGEOMETRYTYPE                      = 919
	RelationalLexerGEOMFROMTEXT                      = 920
	RelationalLexerGEOMFROMWKB                       = 921
	RelationalLexerGET_FORMAT                        = 922
	RelationalLexerGET_LOCK                          = 923
	RelationalLexerGLENGTH                           = 924
	RelationalLexerGREATEST                          = 925
	RelationalLexerGTID_SUBSET                       = 926
	RelationalLexerGTID_SUBTRACT                     = 927
	RelationalLexerHEX                               = 928
	RelationalLexerIFNULL                            = 929
	RelationalLexerINET6_ATON                        = 930
	RelationalLexerINET6_NTOA                        = 931
	RelationalLexerINET_ATON                         = 932
	RelationalLexerINET_NTOA                         = 933
	RelationalLexerINSTR                             = 934
	RelationalLexerINTERIORRINGN                     = 935
	RelationalLexerINTERMINGLE_TABLES                = 936
	RelationalLexerINTERSECTS                        = 937
	RelationalLexerISCLOSED                          = 938
	RelationalLexerISEMPTY                           = 939
	RelationalLexerISNULL                            = 940
	RelationalLexerISSIMPLE                          = 941
	RelationalLexerIS_FREE_LOCK                      = 942
	RelationalLexerIS_IPV4                           = 943
	RelationalLexerIS_IPV4_COMPAT                    = 944
	RelationalLexerIS_IPV4_MAPPED                    = 945
	RelationalLexerIS_IPV6                           = 946
	RelationalLexerIS_USED_LOCK                      = 947
	RelationalLexerLAST_INSERT_ID                    = 948
	RelationalLexerLCASE                             = 949
	RelationalLexerLEAST                             = 950
	RelationalLexerLEN                               = 951
	RelationalLexerLENGTH                            = 952
	RelationalLexerLINEFROMTEXT                      = 953
	RelationalLexerLINEFROMWKB                       = 954
	RelationalLexerLINESTRINGFROMTEXT                = 955
	RelationalLexerLINESTRINGFROMWKB                 = 956
	RelationalLexerLN                                = 957
	RelationalLexerLOAD_FILE                         = 958
	RelationalLexerLOCATE                            = 959
	RelationalLexerLOG10                             = 960
	RelationalLexerLOG2                              = 961
	RelationalLexerLOG                               = 962
	RelationalLexerLOWER                             = 963
	RelationalLexerLPAD                              = 964
	RelationalLexerLTRIM                             = 965
	RelationalLexerCONNECTIVITY                      = 966
	RelationalLexerMAINTAIN_STATS_PROBABILITY        = 967
	RelationalLexerMAKEDATE                          = 968
	RelationalLexerMAKETIME                          = 969
	RelationalLexerMAKE_SET                          = 970
	RelationalLexerMASTER_POS_WAIT                   = 971
	RelationalLexerMBRCONTAINS                       = 972
	RelationalLexerMBRDISJOINT                       = 973
	RelationalLexerMBREQUAL                          = 974
	RelationalLexerMBRINTERSECTS                     = 975
	RelationalLexerMBROVERLAPS                       = 976
	RelationalLexerMBRTOUCHES                        = 977
	RelationalLexerMBRWITHIN                         = 978
	RelationalLexerMD5                               = 979
	RelationalLexerMETRIC                            = 980
	RelationalLexerMLINEFROMTEXT                     = 981
	RelationalLexerMLINEFROMWKB                      = 982
	RelationalLexerMONTHNAME                         = 983
	RelationalLexerMPOINTFROMTEXT                    = 984
	RelationalLexerMPOINTFROMWKB                     = 985
	RelationalLexerMPOLYFROMTEXT                     = 986
	RelationalLexerMPOLYFROMWKB                      = 987
	RelationalLexerMULTILINESTRINGFROMTEXT           = 988
	RelationalLexerMULTILINESTRINGFROMWKB            = 989
	RelationalLexerMULTIPOINTFROMTEXT                = 990
	RelationalLexerMULTIPOINTFROMWKB                 = 991
	RelationalLexerMULTIPOLYGONFROMTEXT              = 992
	RelationalLexerMULTIPOLYGONFROMWKB               = 993
	RelationalLexerM_MAX                             = 994
	RelationalLexerM_MAX_0                           = 995
	RelationalLexerNAME_CONST                        = 996
	RelationalLexerNULLIF                            = 997
	RelationalLexerNUMGEOMETRIES                     = 998
	RelationalLexerNUMINTERIORRINGS                  = 999
	RelationalLexerNUMPOINTS                         = 1000
	RelationalLexerOCT                               = 1001
	RelationalLexerOCTET_LENGTH                      = 1002
	RelationalLexerORD                               = 1003
	RelationalLexerOVERLAPS                          = 1004
	RelationalLexerPERIOD_ADD                        = 1005
	RelationalLexerPERIOD_DIFF                       = 1006
	RelationalLexerPI                                = 1007
	RelationalLexerPOINTFROMTEXT                     = 1008
	RelationalLexerPOINTFROMWKB                      = 1009
	RelationalLexerPOINTN                            = 1010
	RelationalLexerPOLYFROMTEXT                      = 1011
	RelationalLexerPOLYFROMWKB                       = 1012
	RelationalLexerPOLYGONFROMTEXT                   = 1013
	RelationalLexerPOLYGONFROMWKB                    = 1014
	RelationalLexerPOW                               = 1015
	RelationalLexerPOWER                             = 1016
	RelationalLexerQUOTE                             = 1017
	RelationalLexerRABITQ_NUM_EX_BITS                = 1018
	RelationalLexerRADIANS                           = 1019
	RelationalLexerRAND                              = 1020
	RelationalLexerRANDOM_BYTES                      = 1021
	RelationalLexerRELEASE_LOCK                      = 1022
	RelationalLexerREVERSE                           = 1023
	RelationalLexerROUND                             = 1024
	RelationalLexerROW_COUNT                         = 1025
	RelationalLexerRPAD                              = 1026
	RelationalLexerRTRIM                             = 1027
	RelationalLexerRUN                               = 1028
	RelationalLexerSAMPLE_VECTOR_STATS_PROBABILITY   = 1029
	RelationalLexerSCHEMA_NAME                       = 1030
	RelationalLexerSECONDARY_ENGINE_ATTRIBUTE        = 1031
	RelationalLexerSEC_TO_TIME                       = 1032
	RelationalLexerSESSION_USER                      = 1033
	RelationalLexerSHA1                              = 1034
	RelationalLexerSHA2                              = 1035
	RelationalLexerSHA                               = 1036
	RelationalLexerSIGN                              = 1037
	RelationalLexerSIN                               = 1038
	RelationalLexerSLEEP                             = 1039
	RelationalLexerSOUNDEX                           = 1040
	RelationalLexerSQL_THREAD_WAIT_AFTER_GTIDS       = 1041
	RelationalLexerSQRT                              = 1042
	RelationalLexerSRID                              = 1043
	RelationalLexerSTARTPOINT                        = 1044
	RelationalLexerSTATS_THRESHOLD                   = 1045
	RelationalLexerSTORE_ROW_VERSIONS                = 1046
	RelationalLexerSTRCMP                            = 1047
	RelationalLexerSTR_TO_DATE                       = 1048
	RelationalLexerST_AREA                           = 1049
	RelationalLexerST_ASBINARY                       = 1050
	RelationalLexerST_ASTEXT                         = 1051
	RelationalLexerST_ASWKB                          = 1052
	RelationalLexerST_ASWKT                          = 1053
	RelationalLexerST_BUFFER                         = 1054
	RelationalLexerST_CENTROID                       = 1055
	RelationalLexerST_CONTAINS                       = 1056
	RelationalLexerST_CROSSES                        = 1057
	RelationalLexerST_DIFFERENCE                     = 1058
	RelationalLexerST_DIMENSION                      = 1059
	RelationalLexerST_DISJOINT                       = 1060
	RelationalLexerST_DISTANCE                       = 1061
	RelationalLexerST_ENDPOINT                       = 1062
	RelationalLexerST_ENVELOPE                       = 1063
	RelationalLexerST_EQUALS                         = 1064
	RelationalLexerST_EXTERIORRING                   = 1065
	RelationalLexerST_GEOMCOLLFROMTEXT               = 1066
	RelationalLexerST_GEOMCOLLFROMTXT                = 1067
	RelationalLexerST_GEOMCOLLFROMWKB                = 1068
	RelationalLexerST_GEOMETRYCOLLECTIONFROMTEXT     = 1069
	RelationalLexerST_GEOMETRYCOLLECTIONFROMWKB      = 1070
	RelationalLexerST_GEOMETRYFROMTEXT               = 1071
	RelationalLexerST_GEOMETRYFROMWKB                = 1072
	RelationalLexerST_GEOMETRYN                      = 1073
	RelationalLexerST_GEOMETRYTYPE                   = 1074
	RelationalLexerST_GEOMFROMTEXT                   = 1075
	RelationalLexerST_GEOMFROMWKB                    = 1076
	RelationalLexerST_INTERIORRINGN                  = 1077
	RelationalLexerST_INTERSECTION                   = 1078
	RelationalLexerST_INTERSECTS                     = 1079
	RelationalLexerST_ISCLOSED                       = 1080
	RelationalLexerST_ISEMPTY                        = 1081
	RelationalLexerST_ISSIMPLE                       = 1082
	RelationalLexerST_LINEFROMTEXT                   = 1083
	RelationalLexerST_LINEFROMWKB                    = 1084
	RelationalLexerST_LINESTRINGFROMTEXT             = 1085
	RelationalLexerST_LINESTRINGFROMWKB              = 1086
	RelationalLexerST_NUMGEOMETRIES                  = 1087
	RelationalLexerST_NUMINTERIORRING                = 1088
	RelationalLexerST_NUMINTERIORRINGS               = 1089
	RelationalLexerST_NUMPOINTS                      = 1090
	RelationalLexerST_OVERLAPS                       = 1091
	RelationalLexerST_POINTFROMTEXT                  = 1092
	RelationalLexerST_POINTFROMWKB                   = 1093
	RelationalLexerST_POINTN                         = 1094
	RelationalLexerST_POLYFROMTEXT                   = 1095
	RelationalLexerST_POLYFROMWKB                    = 1096
	RelationalLexerST_POLYGONFROMTEXT                = 1097
	RelationalLexerST_POLYGONFROMWKB                 = 1098
	RelationalLexerST_SRID                           = 1099
	RelationalLexerST_STARTPOINT                     = 1100
	RelationalLexerST_SYMDIFFERENCE                  = 1101
	RelationalLexerST_TOUCHES                        = 1102
	RelationalLexerST_UNION                          = 1103
	RelationalLexerST_WITHIN                         = 1104
	RelationalLexerST_X                              = 1105
	RelationalLexerST_Y                              = 1106
	RelationalLexerSUBDATE                           = 1107
	RelationalLexerSUBSTRING_INDEX                   = 1108
	RelationalLexerSUBTIME                           = 1109
	RelationalLexerSYSTEM_USER                       = 1110
	RelationalLexerTAN                               = 1111
	RelationalLexerTIMEDIFF                          = 1112
	RelationalLexerTIMESTAMPADD                      = 1113
	RelationalLexerTIMESTAMPDIFF                     = 1114
	RelationalLexerTIME_FORMAT                       = 1115
	RelationalLexerTIME_TO_SEC                       = 1116
	RelationalLexerTOUCHES                           = 1117
	RelationalLexerTO_BASE64                         = 1118
	RelationalLexerTO_DAYS                           = 1119
	RelationalLexerTO_SECONDS                        = 1120
	RelationalLexerUCASE                             = 1121
	RelationalLexerUNCOMPRESS                        = 1122
	RelationalLexerUNCOMPRESSED_LENGTH               = 1123
	RelationalLexerUNHEX                             = 1124
	RelationalLexerUNIX_TIMESTAMP                    = 1125
	RelationalLexerUPDATEXML                         = 1126
	RelationalLexerUPPER                             = 1127
	RelationalLexerUSE_RABITQ                        = 1128
	RelationalLexerUUID                              = 1129
	RelationalLexerUUID_SHORT                        = 1130
	RelationalLexerVALIDATE_PASSWORD_STRENGTH        = 1131
	RelationalLexerVERSION                           = 1132
	RelationalLexerWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS = 1133
	RelationalLexerWEEKDAY                           = 1134
	RelationalLexerWEEKOFYEAR                        = 1135
	RelationalLexerWEIGHT_STRING                     = 1136
	RelationalLexerWITHIN                            = 1137
	RelationalLexerX_FUNCTION                        = 1138
	RelationalLexerYEARWEEK                          = 1139
	RelationalLexerY_FUNCTION                        = 1140
	RelationalLexerNAMED_ARG_ASSIGN_TOKEN            = 1141
	RelationalLexerVAR_ASSIGN                        = 1142
	RelationalLexerPLUS_ASSIGN                       = 1143
	RelationalLexerMINUS_ASSIGN                      = 1144
	RelationalLexerMULT_ASSIGN                       = 1145
	RelationalLexerDIV_ASSIGN                        = 1146
	RelationalLexerMOD_ASSIGN                        = 1147
	RelationalLexerAND_ASSIGN                        = 1148
	RelationalLexerXOR_ASSIGN                        = 1149
	RelationalLexerOR_ASSIGN                         = 1150
	RelationalLexerSTAR                              = 1151
	RelationalLexerDIVIDE                            = 1152
	RelationalLexerMODULE                            = 1153
	RelationalLexerPLUS                              = 1154
	RelationalLexerMINUS                             = 1155
	RelationalLexerDIV                               = 1156
	RelationalLexerMOD                               = 1157
	RelationalLexerEQUAL_SYMBOL                      = 1158
	RelationalLexerGREATER_SYMBOL                    = 1159
	RelationalLexerLESS_SYMBOL                       = 1160
	RelationalLexerEXCLAMATION_SYMBOL                = 1161
	RelationalLexerBIT_NOT_OP                        = 1162
	RelationalLexerBIT_OR_OP                         = 1163
	RelationalLexerBIT_AND_OP                        = 1164
	RelationalLexerBIT_XOR_OP                        = 1165
	RelationalLexerDOT                               = 1166
	RelationalLexerLEFT_ROUND_BRACKET                = 1167
	RelationalLexerRIGHT_ROUND_BRACKET               = 1168
	RelationalLexerLEFT_CURLY_BRACKET                = 1169
	RelationalLexerRIGHT_CURLY_BRACKET               = 1170
	RelationalLexerLEFT_SQUARE_BRACKET               = 1171
	RelationalLexerRIGHT_SQUARE_BRACKET              = 1172
	RelationalLexerCOMMA                             = 1173
	RelationalLexerSEMI                              = 1174
	RelationalLexerAT_SIGN                           = 1175
	RelationalLexerSINGLE_QUOTE_SYMB                 = 1176
	RelationalLexerDOUBLE_QUOTE_SYMB                 = 1177
	RelationalLexerCOLON_SYMB                        = 1178
	RelationalLexerFILESIZE_LITERAL                  = 1179
	RelationalLexerSTART_NATIONAL_STRING_LITERAL     = 1180
	RelationalLexerSTRING_LITERAL                    = 1181
	RelationalLexerDECIMAL_LITERAL                   = 1182
	RelationalLexerHEXADECIMAL_LITERAL               = 1183
	RelationalLexerBASE64_LITERAL                    = 1184
	RelationalLexerREAL_LITERAL                      = 1185
	RelationalLexerNULL_SPEC_LITERAL                 = 1186
	RelationalLexerBIT_STRING                        = 1187
	RelationalLexerSTRING_CHARSET_NAME               = 1188
	RelationalLexerQUESTION                          = 1189
	RelationalLexerNAMED_PARAMETER                   = 1190
	RelationalLexerID                                = 1191
	RelationalLexerDOUBLE_QUOTE_ID                   = 1192
	RelationalLexerSTRING_USER_NAME                  = 1193
	RelationalLexerIP_ADDRESS                        = 1194
	RelationalLexerLOCAL_ID                          = 1195
	RelationalLexerERROR_RECOGNITION                 = 1196
	RelationalLexerBLOCK_COMMENT_OPEN                = 1197
	RelationalLexerBLOCK_COMMENT_CLOSE               = 1198
	RelationalLexerBLOCK_COMMENT_BODY                = 1199
)

RelationalLexer tokens.

View Source
const (
	RelationalParserEOF                               = antlr.TokenEOF
	RelationalParserSPACE                             = 1
	RelationalParserCOMMENT_INPUT                     = 2
	RelationalParserLINE_COMMENT                      = 3
	RelationalParserADD                               = 4
	RelationalParserALL                               = 5
	RelationalParserALTER                             = 6
	RelationalParserALWAYS                            = 7
	RelationalParserANALYZE                           = 8
	RelationalParserAND                               = 9
	RelationalParserARRAY                             = 10
	RelationalParserAS                                = 11
	RelationalParserASC                               = 12
	RelationalParserATTRIBUTES                        = 13
	RelationalParserBEFORE                            = 14
	RelationalParserBETWEEN                           = 15
	RelationalParserBOTH                              = 16
	RelationalParserBUCKETS                           = 17
	RelationalParserBY                                = 18
	RelationalParserCALL                              = 19
	RelationalParserCALLED                            = 20
	RelationalParserCASCADE                           = 21
	RelationalParserCASE                              = 22
	RelationalParserCAST                              = 23
	RelationalParserCHANGE                            = 24
	RelationalParserCHARACTER                         = 25
	RelationalParserCHECK                             = 26
	RelationalParserCOLLATE                           = 27
	RelationalParserCOLUMN                            = 28
	RelationalParserCONDITION                         = 29
	RelationalParserCONSTRAINT                        = 30
	RelationalParserCONTINUE                          = 31
	RelationalParserCONVERT                           = 32
	RelationalParserCREATE                            = 33
	RelationalParserCROSS                             = 34
	RelationalParserCURRENT                           = 35
	RelationalParserCURRENT_USER                      = 36
	RelationalParserCURSOR                            = 37
	RelationalParserDATABASE                          = 38
	RelationalParserDATABASES                         = 39
	RelationalParserDECLARE                           = 40
	RelationalParserDEEP                              = 41
	RelationalParserDEFAULT                           = 42
	RelationalParserDELAYED                           = 43
	RelationalParserDELETE                            = 44
	RelationalParserDESC                              = 45
	RelationalParserDESCRIBE                          = 46
	RelationalParserDETERMINISTIC                     = 47
	RelationalParserDIAGNOSTICS                       = 48
	RelationalParserDISPATCH                          = 49
	RelationalParserDISTINCT                          = 50
	RelationalParserDISTINCTROW                       = 51
	RelationalParserDROP                              = 52
	RelationalParserEACH                              = 53
	RelationalParserELSE                              = 54
	RelationalParserELSEIF                            = 55
	RelationalParserEMPTY                             = 56
	RelationalParserENCLOSED                          = 57
	RelationalParserESCAPED                           = 58
	RelationalParserEXCEPT                            = 59
	RelationalParserEXISTS                            = 60
	RelationalParserEXIT                              = 61
	RelationalParserEXPLAIN                           = 62
	RelationalParserFALSE                             = 63
	RelationalParserFETCH                             = 64
	RelationalParserFOR                               = 65
	RelationalParserFORCE                             = 66
	RelationalParserFOREIGN                           = 67
	RelationalParserFROM                              = 68
	RelationalParserFULLTEXT                          = 69
	RelationalParserGENERATED                         = 70
	RelationalParserGET                               = 71
	RelationalParserGRANT                             = 72
	RelationalParserGROUP                             = 73
	RelationalParserHAVING                            = 74
	RelationalParserHNSW                              = 75
	RelationalParserGUARDIANN                         = 76
	RelationalParserSPFRESH                           = 77
	RelationalParserHIGH_PRIORITY                     = 78
	RelationalParserHISTOGRAM                         = 79
	RelationalParserIF                                = 80
	RelationalParserIGNORE                            = 81
	RelationalParserIGNORED                           = 82
	RelationalParserIN                                = 83
	RelationalParserINDEX                             = 84
	RelationalParserINFILE                            = 85
	RelationalParserINNER                             = 86
	RelationalParserINOUT                             = 87
	RelationalParserINPUT                             = 88
	RelationalParserINSERT                            = 89
	RelationalParserINTERVAL                          = 90
	RelationalParserINTO                              = 91
	RelationalParserIS                                = 92
	RelationalParserITERATE                           = 93
	RelationalParserJOIN                              = 94
	RelationalParserKEY                               = 95
	RelationalParserKEYS                              = 96
	RelationalParserKILL                              = 97
	RelationalParserLEADING                           = 98
	RelationalParserLEAVE                             = 99
	RelationalParserLEFT                              = 100
	RelationalParserLIKE                              = 101
	RelationalParserLIMIT                             = 102
	RelationalParserLINEAR                            = 103
	RelationalParserLINES                             = 104
	RelationalParserLOAD                              = 105
	RelationalParserLOCK                              = 106
	RelationalParserLOOP                              = 107
	RelationalParserLOW_PRIORITY                      = 108
	RelationalParserMASTER_BIND                       = 109
	RelationalParserMASTER_SSL_VERIFY_SERVER_CERT     = 110
	RelationalParserMATCH                             = 111
	RelationalParserMAXVALUE                          = 112
	RelationalParserMODIFIES                          = 113
	RelationalParserNATURAL                           = 114
	RelationalParserNOT                               = 115
	RelationalParserNO_WRITE_TO_BINLOG                = 116
	RelationalParserNULL_LITERAL                      = 117
	RelationalParserNUMBER                            = 118
	RelationalParserOFF                               = 119
	RelationalParserON                                = 120
	RelationalParserOPTIMIZE                          = 121
	RelationalParserOPTION                            = 122
	RelationalParserOPTIONAL                          = 123
	RelationalParserOPTIONALLY                        = 124
	RelationalParserOR                                = 125
	RelationalParserORDER                             = 126
	RelationalParserOUT                               = 127
	RelationalParserOVER                              = 128
	RelationalParserOUTER                             = 129
	RelationalParserOUTFILE                           = 130
	RelationalParserPARTITION                         = 131
	RelationalParserPLAN                              = 132
	RelationalParserPRIMARY                           = 133
	RelationalParserPROCEDURE                         = 134
	RelationalParserPURGE                             = 135
	RelationalParserQUALIFY                           = 136
	RelationalParserREAD                              = 137
	RelationalParserREADS                             = 138
	RelationalParserRECURSIVE                         = 139
	RelationalParserREFERENCES                        = 140
	RelationalParserREGEXP                            = 141
	RelationalParserRELEASE                           = 142
	RelationalParserRENAME                            = 143
	RelationalParserREPEAT                            = 144
	RelationalParserREPLACE                           = 145
	RelationalParserREQUIRE                           = 146
	RelationalParserRESIGNAL                          = 147
	RelationalParserRESTRICT                          = 148
	RelationalParserRETAIN                            = 149
	RelationalParserRETURN                            = 150
	RelationalParserREVOKE                            = 151
	RelationalParserRIGHT                             = 152
	RelationalParserRLIKE                             = 153
	RelationalParserSCHEMA                            = 154
	RelationalParserSCHEMAS                           = 155
	RelationalParserSELECT                            = 156
	RelationalParserSET                               = 157
	RelationalParserSEPARATOR                         = 158
	RelationalParserSHOW                              = 159
	RelationalParserSIGNAL                            = 160
	RelationalParserSPATIAL                           = 161
	RelationalParserSQL                               = 162
	RelationalParserSQLEXCEPTION                      = 163
	RelationalParserSQLSTATE                          = 164
	RelationalParserSQLWARNING                        = 165
	RelationalParserSQL_BIG_RESULT                    = 166
	RelationalParserSQL_CALC_FOUND_ROWS               = 167
	RelationalParserSQL_SMALL_RESULT                  = 168
	RelationalParserSSL                               = 169
	RelationalParserSTATIC                            = 170
	RelationalParserSTACKED                           = 171
	RelationalParserSTARTING                          = 172
	RelationalParserSTRAIGHT_JOIN                     = 173
	RelationalParserTABLE                             = 174
	RelationalParserTERMINATED                        = 175
	RelationalParserTHEN                              = 176
	RelationalParserTO                                = 177
	RelationalParserTRAILING                          = 178
	RelationalParserTRAVERSAL                         = 179
	RelationalParserTRIGGER                           = 180
	RelationalParserTRUE                              = 181
	RelationalParserUNDO                              = 182
	RelationalParserUNION                             = 183
	RelationalParserUNIQUE                            = 184
	RelationalParserUNLOCK                            = 185
	RelationalParserUNSIGNED                          = 186
	RelationalParserUPDATE                            = 187
	RelationalParserUSAGE                             = 188
	RelationalParserUSE                               = 189
	RelationalParserUSING                             = 190
	RelationalParserVALUES                            = 191
	RelationalParserWHEN                              = 192
	RelationalParserWHERE                             = 193
	RelationalParserWHILE                             = 194
	RelationalParserWITH                              = 195
	RelationalParserCONTINUATION                      = 196
	RelationalParserWRITE                             = 197
	RelationalParserXOR                               = 198
	RelationalParserZEROFILL                          = 199
	RelationalParserTINYINT                           = 200
	RelationalParserSMALLINT                          = 201
	RelationalParserMEDIUMINT                         = 202
	RelationalParserMIDDLEINT                         = 203
	RelationalParserINT                               = 204
	RelationalParserINT1                              = 205
	RelationalParserINT2                              = 206
	RelationalParserINT3                              = 207
	RelationalParserINT4                              = 208
	RelationalParserINT8                              = 209
	RelationalParserINT32                             = 210
	RelationalParserINT64                             = 211
	RelationalParserINTEGER                           = 212
	RelationalParserBIGINT                            = 213
	RelationalParserBYTES                             = 214
	RelationalParserREAL                              = 215
	RelationalParserDOUBLE                            = 216
	RelationalParserPRECISION                         = 217
	RelationalParserFLOAT                             = 218
	RelationalParserFLOAT4                            = 219
	RelationalParserFLOAT8                            = 220
	RelationalParserDECIMAL                           = 221
	RelationalParserDEC                               = 222
	RelationalParserNUMERIC                           = 223
	RelationalParserDATE                              = 224
	RelationalParserTIME                              = 225
	RelationalParserTIMESTAMP                         = 226
	RelationalParserDATETIME                          = 227
	RelationalParserYEAR                              = 228
	RelationalParserCHAR                              = 229
	RelationalParserVARCHAR                           = 230
	RelationalParserNVARCHAR                          = 231
	RelationalParserNATIONAL                          = 232
	RelationalParserBINARY                            = 233
	RelationalParserVARBINARY                         = 234
	RelationalParserTINYBLOB                          = 235
	RelationalParserBLOB                              = 236
	RelationalParserMEDIUMBLOB                        = 237
	RelationalParserLONG                              = 238
	RelationalParserLONGBLOB                          = 239
	RelationalParserTINYTEXT                          = 240
	RelationalParserTEXT                              = 241
	RelationalParserMEDIUMTEXT                        = 242
	RelationalParserLONGTEXT                          = 243
	RelationalParserENUM                              = 244
	RelationalParserVARYING                           = 245
	RelationalParserSERIAL                            = 246
	RelationalParserMESSAGE                           = 247
	RelationalParserYEAR_MONTH                        = 248
	RelationalParserDAY_HOUR                          = 249
	RelationalParserDAY_MINUTE                        = 250
	RelationalParserDAY_SECOND                        = 251
	RelationalParserHOUR_MINUTE                       = 252
	RelationalParserHOUR_SECOND                       = 253
	RelationalParserMINUTE_SECOND                     = 254
	RelationalParserSECOND_MICROSECOND                = 255
	RelationalParserMINUTE_MICROSECOND                = 256
	RelationalParserHOUR_MICROSECOND                  = 257
	RelationalParserDAY_MICROSECOND                   = 258
	RelationalParserJSON_ARRAY                        = 259
	RelationalParserJSON_OBJECT                       = 260
	RelationalParserJSON_QUOTE                        = 261
	RelationalParserJSON_CONTAINS                     = 262
	RelationalParserJSON_CONTAINS_PATH                = 263
	RelationalParserJSON_EXTRACT                      = 264
	RelationalParserJSON_KEYS                         = 265
	RelationalParserJSON_OVERLAPS                     = 266
	RelationalParserJSON_SEARCH                       = 267
	RelationalParserJSON_VALUE                        = 268
	RelationalParserJSON_ARRAY_APPEND                 = 269
	RelationalParserJSON_ARRAY_INSERT                 = 270
	RelationalParserJSON_INSERT                       = 271
	RelationalParserJSON_MERGE                        = 272
	RelationalParserJSON_MERGE_PATCH                  = 273
	RelationalParserJSON_MERGE_PRESERVE               = 274
	RelationalParserJSON_REMOVE                       = 275
	RelationalParserJSON_REPLACE                      = 276
	RelationalParserJSON_SET                          = 277
	RelationalParserJSON_UNQUOTE                      = 278
	RelationalParserJSON_DEPTH                        = 279
	RelationalParserJSON_LENGTH                       = 280
	RelationalParserJSON_TYPE                         = 281
	RelationalParserJSON_VALID                        = 282
	RelationalParserJSON_TABLE                        = 283
	RelationalParserJSON_SCHEMA_VALID                 = 284
	RelationalParserJSON_SCHEMA_VALIDATION_REPORT     = 285
	RelationalParserJSON_PRETTY                       = 286
	RelationalParserJSON_STORAGE_FREE                 = 287
	RelationalParserJSON_STORAGE_SIZE                 = 288
	RelationalParserJSON_ARRAYAGG                     = 289
	RelationalParserJSON_OBJECTAGG                    = 290
	RelationalParserARRAY_AGG                         = 291
	RelationalParserAVG                               = 292
	RelationalParserBIT_AND                           = 293
	RelationalParserBITMAP_BIT_POSITION               = 294
	RelationalParserBITMAP_BUCKET_OFFSET              = 295
	RelationalParserBITMAP_BUCKET_NUMBER              = 296
	RelationalParserBITMAP_CONSTRUCT_AGG              = 297
	RelationalParserBIT_OR                            = 298
	RelationalParserBIT_XOR                           = 299
	RelationalParserCOUNT                             = 300
	RelationalParserCUME_DIST                         = 301
	RelationalParserDENSE_RANK                        = 302
	RelationalParserFIRST_VALUE                       = 303
	RelationalParserGROUP_CONCAT                      = 304
	RelationalParserLAG                               = 305
	RelationalParserLAST_VALUE                        = 306
	RelationalParserLEAD                              = 307
	RelationalParserMAX                               = 308
	RelationalParserMAX_EVER                          = 309
	RelationalParserMIN                               = 310
	RelationalParserMIN_EVER                          = 311
	RelationalParserNTILE                             = 312
	RelationalParserNTH_VALUE                         = 313
	RelationalParserPERCENT_RANK                      = 314
	RelationalParserRANK                              = 315
	RelationalParserROW_NUMBER                        = 316
	RelationalParserSTD                               = 317
	RelationalParserSTDDEV                            = 318
	RelationalParserSTDDEV_POP                        = 319
	RelationalParserSTDDEV_SAMP                       = 320
	RelationalParserSUM                               = 321
	RelationalParserVAR_POP                           = 322
	RelationalParserVAR_SAMP                          = 323
	RelationalParserVARIANCE                          = 324
	RelationalParserCURRENT_DATE                      = 325
	RelationalParserCURRENT_TIME                      = 326
	RelationalParserCURRENT_TIMESTAMP                 = 327
	RelationalParserLOCALTIME                         = 328
	RelationalParserCURDATE                           = 329
	RelationalParserCURTIME                           = 330
	RelationalParserDATE_ADD                          = 331
	RelationalParserDATE_SUB                          = 332
	RelationalParserEXTRACT                           = 333
	RelationalParserLOCALTIMESTAMP                    = 334
	RelationalParserNOW                               = 335
	RelationalParserPOSITION                          = 336
	RelationalParserSUBSTR                            = 337
	RelationalParserSUBSTRING                         = 338
	RelationalParserSYSDATE                           = 339
	RelationalParserTRIM                              = 340
	RelationalParserUTC_DATE                          = 341
	RelationalParserUTC_TIME                          = 342
	RelationalParserUTC_TIMESTAMP                     = 343
	RelationalParserJAVA_CALL                         = 344
	RelationalParserACCOUNT                           = 345
	RelationalParserACTION                            = 346
	RelationalParserAFTER                             = 347
	RelationalParserAGGREGATE                         = 348
	RelationalParserALGORITHM                         = 349
	RelationalParserANY                               = 350
	RelationalParserAT                                = 351
	RelationalParserAUTHORS                           = 352
	RelationalParserAUTOCOMMIT                        = 353
	RelationalParserAUTOEXTEND_SIZE                   = 354
	RelationalParserAUTO_INCREMENT                    = 355
	RelationalParserAVG_ROW_LENGTH                    = 356
	RelationalParserBEGIN                             = 357
	RelationalParserBINLOG                            = 358
	RelationalParserBIT                               = 359
	RelationalParserBLOCK                             = 360
	RelationalParserBOOL                              = 361
	RelationalParserBOOLEAN                           = 362
	RelationalParserBTREE                             = 363
	RelationalParserCACHE                             = 364
	RelationalParserCASCADED                          = 365
	RelationalParserCHAIN                             = 366
	RelationalParserCHANGED                           = 367
	RelationalParserCHANNEL                           = 368
	RelationalParserCHECKSUM                          = 369
	RelationalParserCOMPILED                          = 370
	RelationalParserPAGE_CHECKSUM                     = 371
	RelationalParserCIPHER                            = 372
	RelationalParserCLASS_ORIGIN                      = 373
	RelationalParserCLIENT                            = 374
	RelationalParserCLOSE                             = 375
	RelationalParserCLUSTERING                        = 376
	RelationalParserCOALESCE                          = 377
	RelationalParserCODE                              = 378
	RelationalParserCOLUMNS                           = 379
	RelationalParserCOLUMN_FORMAT                     = 380
	RelationalParserCOLUMN_NAME                       = 381
	RelationalParserCOMMENT                           = 382
	RelationalParserCOMMIT                            = 383
	RelationalParserCOMPACT                           = 384
	RelationalParserCOMPLETION                        = 385
	RelationalParserCOMPRESSED                        = 386
	RelationalParserCOMPRESSION                       = 387
	RelationalParserCONCURRENT                        = 388
	RelationalParserCONNECT                           = 389
	RelationalParserCONNECTION                        = 390
	RelationalParserCONSISTENT                        = 391
	RelationalParserCONSTRAINT_CATALOG                = 392
	RelationalParserCONSTRAINT_SCHEMA                 = 393
	RelationalParserCONSTRAINT_NAME                   = 394
	RelationalParserCONTAINS                          = 395
	RelationalParserCONTEXT                           = 396
	RelationalParserCONTRIBUTORS                      = 397
	RelationalParserCOPY                              = 398
	RelationalParserCPU                               = 399
	RelationalParserCURSOR_NAME                       = 400
	RelationalParserDATA                              = 401
	RelationalParserDATAFILE                          = 402
	RelationalParserDEALLOCATE                        = 403
	RelationalParserDEFAULT_AUTH                      = 404
	RelationalParserDEFINER                           = 405
	RelationalParserDELAY_KEY_WRITE                   = 406
	RelationalParserDES_KEY_FILE                      = 407
	RelationalParserDIRECTORY                         = 408
	RelationalParserDISABLE                           = 409
	RelationalParserDISCARD                           = 410
	RelationalParserDISK                              = 411
	RelationalParserDO                                = 412
	RelationalParserDUMPFILE                          = 413
	RelationalParserDUPLICATE                         = 414
	RelationalParserDYNAMIC                           = 415
	RelationalParserENABLE                            = 416
	RelationalParserENCRYPTION                        = 417
	RelationalParserEND                               = 418
	RelationalParserENDS                              = 419
	RelationalParserENGINE                            = 420
	RelationalParserENGINES                           = 421
	RelationalParserERROR                             = 422
	RelationalParserERRORS                            = 423
	RelationalParserESCAPE                            = 424
	RelationalParserEVEN                              = 425
	RelationalParserEVENT                             = 426
	RelationalParserEVENTS                            = 427
	RelationalParserEVERY                             = 428
	RelationalParserEXCHANGE                          = 429
	RelationalParserEXCLUSIVE                         = 430
	RelationalParserEXPIRE                            = 431
	RelationalParserEXPORT                            = 432
	RelationalParserEXTENDED                          = 433
	RelationalParserEXTENT_SIZE                       = 434
	RelationalParserFAST                              = 435
	RelationalParserFAULTS                            = 436
	RelationalParserFIELDS                            = 437
	RelationalParserFILE_BLOCK_SIZE                   = 438
	RelationalParserFILTER                            = 439
	RelationalParserFIRST                             = 440
	RelationalParserFIXED                             = 441
	RelationalParserFLUSH                             = 442
	RelationalParserFOLLOWING                         = 443
	RelationalParserFOLLOWS                           = 444
	RelationalParserFOUND                             = 445
	RelationalParserFULL                              = 446
	RelationalParserFUNCTION                          = 447
	RelationalParserGENERAL                           = 448
	RelationalParserGLOBAL                            = 449
	RelationalParserGRANTS                            = 450
	RelationalParserGROUP_REPLICATION                 = 451
	RelationalParserHALF                              = 452
	RelationalParserHANDLER                           = 453
	RelationalParserHAS                               = 454
	RelationalParserHASH                              = 455
	RelationalParserHELP                              = 456
	RelationalParserHOST                              = 457
	RelationalParserHOSTS                             = 458
	RelationalParserIDENTIFIED                        = 459
	RelationalParserIGNORE_SERVER_IDS                 = 460
	RelationalParserIMPORT                            = 461
	RelationalParserINCLUDE                           = 462
	RelationalParserINDEXES                           = 463
	RelationalParserINITIAL_SIZE                      = 464
	RelationalParserINPLACE                           = 465
	RelationalParserINSERT_METHOD                     = 466
	RelationalParserINSTALL                           = 467
	RelationalParserINSTANCE                          = 468
	RelationalParserINSTANT                           = 469
	RelationalParserINVISIBLE                         = 470
	RelationalParserINVOKER                           = 471
	RelationalParserIO                                = 472
	RelationalParserIO_THREAD                         = 473
	RelationalParserIPC                               = 474
	RelationalParserISOLATION                         = 475
	RelationalParserISSUER                            = 476
	RelationalParserJAVA                              = 477
	RelationalParserJSON                              = 478
	RelationalParserKEY_BLOCK_SIZE                    = 479
	RelationalParserLANGUAGE                          = 480
	RelationalParserLAST                              = 481
	RelationalParserLEAVES                            = 482
	RelationalParserLESS                              = 483
	RelationalParserLEVEL                             = 484
	RelationalParserLEVEL_ORDER                       = 485
	RelationalParserLIST                              = 486
	RelationalParserLOCAL                             = 487
	RelationalParserLOGFILE                           = 488
	RelationalParserLOGS                              = 489
	RelationalParserMASTER                            = 490
	RelationalParserMASTER_AUTO_POSITION              = 491
	RelationalParserMASTER_CONNECT_RETRY              = 492
	RelationalParserMASTER_DELAY                      = 493
	RelationalParserMASTER_HEARTBEAT_PERIOD           = 494
	RelationalParserMASTER_HOST                       = 495
	RelationalParserMASTER_LOG_FILE                   = 496
	RelationalParserMASTER_LOG_POS                    = 497
	RelationalParserMASTER_PASSWORD                   = 498
	RelationalParserMASTER_PORT                       = 499
	RelationalParserMASTER_RETRY_COUNT                = 500
	RelationalParserMASTER_SSL                        = 501
	RelationalParserMASTER_SSL_CA                     = 502
	RelationalParserMASTER_SSL_CAPATH                 = 503
	RelationalParserMASTER_SSL_CERT                   = 504
	RelationalParserMASTER_SSL_CIPHER                 = 505
	RelationalParserMASTER_SSL_CRL                    = 506
	RelationalParserMASTER_SSL_CRLPATH                = 507
	RelationalParserMASTER_SSL_KEY                    = 508
	RelationalParserMASTER_TLS_VERSION                = 509
	RelationalParserMASTER_USER                       = 510
	RelationalParserMAX_CONNECTIONS_PER_HOUR          = 511
	RelationalParserMAX_QUERIES_PER_HOUR              = 512
	RelationalParserMAX_ROWS                          = 513
	RelationalParserMAX_SIZE                          = 514
	RelationalParserMAX_UPDATES_PER_HOUR              = 515
	RelationalParserMAX_USER_CONNECTIONS              = 516
	RelationalParserMEDIUM                            = 517
	RelationalParserMEMBER                            = 518
	RelationalParserMERGE                             = 519
	RelationalParserMESSAGE_TEXT                      = 520
	RelationalParserMID                               = 521
	RelationalParserMIGRATE                           = 522
	RelationalParserMIN_ROWS                          = 523
	RelationalParserMODE                              = 524
	RelationalParserMODIFY                            = 525
	RelationalParserMUTEX                             = 526
	RelationalParserMYSQL                             = 527
	RelationalParserMYSQL_ERRNO                       = 528
	RelationalParserNAME                              = 529
	RelationalParserNAMES                             = 530
	RelationalParserNCHAR                             = 531
	RelationalParserNEVER                             = 532
	RelationalParserNEXT                              = 533
	RelationalParserNO                                = 534
	RelationalParserNOCOPY                            = 535
	RelationalParserNOWAIT                            = 536
	RelationalParserNODEGROUP                         = 537
	RelationalParserNONE                              = 538
	RelationalParserNOCACHE                           = 539
	RelationalParserNULLS                             = 540
	RelationalParserODBC                              = 541
	RelationalParserOFFLINE                           = 542
	RelationalParserOFFSET                            = 543
	RelationalParserOF                                = 544
	RelationalParserOJ                                = 545
	RelationalParserOLD_PASSWORD                      = 546
	RelationalParserONE                               = 547
	RelationalParserONLINE                            = 548
	RelationalParserONLY                              = 549
	RelationalParserOPEN                              = 550
	RelationalParserOPTIMIZER_COSTS                   = 551
	RelationalParserOPTIONS                           = 552
	RelationalParserOWNER                             = 553
	RelationalParserPACK_KEYS                         = 554
	RelationalParserPAGE                              = 555
	RelationalParserPARAMETER                         = 556
	RelationalParserPARSER                            = 557
	RelationalParserPARTIAL                           = 558
	RelationalParserPARTITIONING                      = 559
	RelationalParserPARTITIONS                        = 560
	RelationalParserPASSWORD                          = 561
	RelationalParserPHASE                             = 562
	RelationalParserPLUGIN                            = 563
	RelationalParserPLUGIN_DIR                        = 564
	RelationalParserPLUGINS                           = 565
	RelationalParserPORT                              = 566
	RelationalParserPOST_ORDER                        = 567
	RelationalParserPRECEDES                          = 568
	RelationalParserPRECEDING                         = 569
	RelationalParserPREFIX                            = 570
	RelationalParserPRE_ORDER                         = 571
	RelationalParserPREPARE                           = 572
	RelationalParserPRESERVE                          = 573
	RelationalParserPREV                              = 574
	RelationalParserPROCESSLIST                       = 575
	RelationalParserPROFILE                           = 576
	RelationalParserPROFILES                          = 577
	RelationalParserPROXY                             = 578
	RelationalParserQUERY                             = 579
	RelationalParserQUICK                             = 580
	RelationalParserREBUILD                           = 581
	RelationalParserRECOVER                           = 582
	RelationalParserREDO_BUFFER_SIZE                  = 583
	RelationalParserREDUNDANT                         = 584
	RelationalParserRELAY                             = 585
	RelationalParserRELAY_LOG_FILE                    = 586
	RelationalParserRELAY_LOG_POS                     = 587
	RelationalParserRELAYLOG                          = 588
	RelationalParserREMOVE                            = 589
	RelationalParserREORGANIZE                        = 590
	RelationalParserREPAIR                            = 591
	RelationalParserREPEATED                          = 592
	RelationalParserREPLICATE_DO_DB                   = 593
	RelationalParserREPLICATE_DO_TABLE                = 594
	RelationalParserREPLICATE_IGNORE_DB               = 595
	RelationalParserREPLICATE_IGNORE_TABLE            = 596
	RelationalParserREPLICATE_REWRITE_DB              = 597
	RelationalParserREPLICATE_WILD_DO_TABLE           = 598
	RelationalParserREPLICATE_WILD_IGNORE_TABLE       = 599
	RelationalParserREPLICATION                       = 600
	RelationalParserRESET                             = 601
	RelationalParserRESPECT                           = 602
	RelationalParserRESUME                            = 603
	RelationalParserRETURNED_SQLSTATE                 = 604
	RelationalParserRETURNING                         = 605
	RelationalParserRETURNS                           = 606
	RelationalParserROLE                              = 607
	RelationalParserROLLBACK                          = 608
	RelationalParserROLLUP                            = 609
	RelationalParserROTATE                            = 610
	RelationalParserROW                               = 611
	RelationalParserROWS                              = 612
	RelationalParserROW_FORMAT                        = 613
	RelationalParserRTREE                             = 614
	RelationalParserSAVEPOINT                         = 615
	RelationalParserSCHEDULE                          = 616
	RelationalParserSECURITY                          = 617
	RelationalParserSERVER                            = 618
	RelationalParserSESSION                           = 619
	RelationalParserSHARE                             = 620
	RelationalParserSHARED                            = 621
	RelationalParserSIGNED                            = 622
	RelationalParserSIMPLE                            = 623
	RelationalParserSINGLE                            = 624
	RelationalParserSLAVE                             = 625
	RelationalParserSLOW                              = 626
	RelationalParserSNAPSHOT                          = 627
	RelationalParserSOCKET                            = 628
	RelationalParserSOME                              = 629
	RelationalParserSONAME                            = 630
	RelationalParserSOUNDS                            = 631
	RelationalParserSOURCE                            = 632
	RelationalParserSQL_AFTER_GTIDS                   = 633
	RelationalParserSQL_AFTER_MTS_GAPS                = 634
	RelationalParserSQL_BEFORE_GTIDS                  = 635
	RelationalParserSQL_BUFFER_RESULT                 = 636
	RelationalParserSQL_THREAD                        = 637
	RelationalParserSTART                             = 638
	RelationalParserSTARTS                            = 639
	RelationalParserSTATEMENT                         = 640
	RelationalParserSTATS_AUTO_RECALC                 = 641
	RelationalParserSTATS_PERSISTENT                  = 642
	RelationalParserSTATS_SAMPLE_PAGES                = 643
	RelationalParserSTATUS                            = 644
	RelationalParserSTOP                              = 645
	RelationalParserSTORAGE                           = 646
	RelationalParserSTORED                            = 647
	RelationalParserSTRING                            = 648
	RelationalParserSTRUCT                            = 649
	RelationalParserSTYLE                             = 650
	RelationalParserSUBCLASS_ORIGIN                   = 651
	RelationalParserSUBJECT                           = 652
	RelationalParserSUBPARTITION                      = 653
	RelationalParserSUBPARTITIONS                     = 654
	RelationalParserSUSPEND                           = 655
	RelationalParserSWAPS                             = 656
	RelationalParserSWITCHES                          = 657
	RelationalParserTABLE_NAME                        = 658
	RelationalParserTABLESPACE                        = 659
	RelationalParserTABLE_TYPE                        = 660
	RelationalParserTEMPLATE                          = 661
	RelationalParserTEMPLATES                         = 662
	RelationalParserTEMPORARY                         = 663
	RelationalParserTEMPTABLE                         = 664
	RelationalParserTHAN                              = 665
	RelationalParserTRADITIONAL                       = 666
	RelationalParserTRANSACTION                       = 667
	RelationalParserTRANSACTIONAL                     = 668
	RelationalParserTRIGGERS                          = 669
	RelationalParserTRUNCATE                          = 670
	RelationalParserTYPE                              = 671
	RelationalParserUNBOUNDED                         = 672
	RelationalParserUNDEFINED                         = 673
	RelationalParserUNDOFILE                          = 674
	RelationalParserUNDO_BUFFER_SIZE                  = 675
	RelationalParserUNINSTALL                         = 676
	RelationalParserUNKNOWN                           = 677
	RelationalParserUNTIL                             = 678
	RelationalParserUPGRADE                           = 679
	RelationalParserUSER                              = 680
	RelationalParserUSE_FRM                           = 681
	RelationalParserUSER_RESOURCES                    = 682
	RelationalParserVALIDATION                        = 683
	RelationalParserVALUE                             = 684
	RelationalParserVARIABLES                         = 685
	RelationalParserVECTOR                            = 686
	RelationalParserVIEW                              = 687
	RelationalParserVIRTUAL                           = 688
	RelationalParserVISIBLE                           = 689
	RelationalParserWAIT                              = 690
	RelationalParserWARNINGS                          = 691
	RelationalParserWINDOW                            = 692
	RelationalParserLEGACY_EXTREMUM_EVER              = 693
	RelationalParserWITHOUT                           = 694
	RelationalParserWORK                              = 695
	RelationalParserWRAPPER                           = 696
	RelationalParserX509                              = 697
	RelationalParserXA                                = 698
	RelationalParserXML                               = 699
	RelationalParserYES                               = 700
	RelationalParserEUR                               = 701
	RelationalParserUSA                               = 702
	RelationalParserJIS                               = 703
	RelationalParserISO                               = 704
	RelationalParserINTERNAL                          = 705
	RelationalParserQUARTER                           = 706
	RelationalParserMONTH                             = 707
	RelationalParserDAY                               = 708
	RelationalParserHOUR                              = 709
	RelationalParserMINUTE                            = 710
	RelationalParserWEEK                              = 711
	RelationalParserSECOND                            = 712
	RelationalParserMICROSECOND                       = 713
	RelationalParserTABLES                            = 714
	RelationalParserROUTINE                           = 715
	RelationalParserEXECUTE                           = 716
	RelationalParserFILE                              = 717
	RelationalParserPROCESS                           = 718
	RelationalParserRELOAD                            = 719
	RelationalParserSHUTDOWN                          = 720
	RelationalParserSUPER                             = 721
	RelationalParserPRIVILEGES                        = 722
	RelationalParserAPPLICATION_PASSWORD_ADMIN        = 723
	RelationalParserAUDIT_ADMIN                       = 724
	RelationalParserBACKUP_ADMIN                      = 725
	RelationalParserBINLOG_ADMIN                      = 726
	RelationalParserBINLOG_ENCRYPTION_ADMIN           = 727
	RelationalParserCLONE_ADMIN                       = 728
	RelationalParserCONNECTION_ADMIN                  = 729
	RelationalParserENCRYPTION_KEY_ADMIN              = 730
	RelationalParserFIREWALL_ADMIN                    = 731
	RelationalParserFIREWALL_USER                     = 732
	RelationalParserFLUSH_OPTIMIZER_COSTS             = 733
	RelationalParserFLUSH_STATUS                      = 734
	RelationalParserFLUSH_TABLES                      = 735
	RelationalParserFLUSH_USER_RESOURCES              = 736
	RelationalParserADMIN                             = 737
	RelationalParserGROUP_REPLICATION_ADMIN           = 738
	RelationalParserINNODB_REDO_LOG_ARCHIVE           = 739
	RelationalParserINNODB_REDO_LOG_ENABLE            = 740
	RelationalParserNDB_STORED_USER                   = 741
	RelationalParserPERSIST_RO_VARIABLES_ADMIN        = 742
	RelationalParserREPLICATION_APPLIER               = 743
	RelationalParserREPLICATION_SLAVE_ADMIN           = 744
	RelationalParserRESOURCE_GROUP_ADMIN              = 745
	RelationalParserRESOURCE_GROUP_USER               = 746
	RelationalParserROLE_ADMIN                        = 747
	RelationalParserSERVICE_CONNECTION_ADMIN          = 748
	RelationalParserSESSION_VARIABLES_ADMIN           = 749
	RelationalParserSET_USER_ID                       = 750
	RelationalParserSHOW_ROUTINE                      = 751
	RelationalParserSYSTEM_VARIABLES_ADMIN            = 752
	RelationalParserTABLE_ENCRYPTION_ADMIN            = 753
	RelationalParserVERSION_TOKEN_ADMIN               = 754
	RelationalParserXA_RECOVER_ADMIN                  = 755
	RelationalParserARMSCII8                          = 756
	RelationalParserASCII                             = 757
	RelationalParserBIG5                              = 758
	RelationalParserCP1250                            = 759
	RelationalParserCP1251                            = 760
	RelationalParserCP1256                            = 761
	RelationalParserCP1257                            = 762
	RelationalParserCP850                             = 763
	RelationalParserCP852                             = 764
	RelationalParserCP866                             = 765
	RelationalParserCP932                             = 766
	RelationalParserDEC8                              = 767
	RelationalParserEUCJPMS                           = 768
	RelationalParserEUCKR                             = 769
	RelationalParserGB18030                           = 770
	RelationalParserGB2312                            = 771
	RelationalParserGBK                               = 772
	RelationalParserGEOSTD8                           = 773
	RelationalParserGREEK                             = 774
	RelationalParserHEBREW                            = 775
	RelationalParserHP8                               = 776
	RelationalParserKEYBCS2                           = 777
	RelationalParserKOI8R                             = 778
	RelationalParserKOI8U                             = 779
	RelationalParserLATIN1                            = 780
	RelationalParserLATIN2                            = 781
	RelationalParserLATIN5                            = 782
	RelationalParserLATIN7                            = 783
	RelationalParserMACCE                             = 784
	RelationalParserMACROMAN                          = 785
	RelationalParserSJIS                              = 786
	RelationalParserSWE7                              = 787
	RelationalParserTIS620                            = 788
	RelationalParserUCS2                              = 789
	RelationalParserUJIS                              = 790
	RelationalParserUTF16                             = 791
	RelationalParserUTF16LE                           = 792
	RelationalParserUTF32                             = 793
	RelationalParserUTF8                              = 794
	RelationalParserUTF8MB3                           = 795
	RelationalParserUTF8MB4                           = 796
	RelationalParserARCHIVE                           = 797
	RelationalParserBLACKHOLE                         = 798
	RelationalParserCSV                               = 799
	RelationalParserFEDERATED                         = 800
	RelationalParserINNODB                            = 801
	RelationalParserMEMORY                            = 802
	RelationalParserMRG_MYISAM                        = 803
	RelationalParserMYISAM                            = 804
	RelationalParserNDB                               = 805
	RelationalParserNDBCLUSTER                        = 806
	RelationalParserPERFORMANCE_SCHEMA                = 807
	RelationalParserTOKUDB                            = 808
	RelationalParserREPEATABLE                        = 809
	RelationalParserCOMMITTED                         = 810
	RelationalParserUNCOMMITTED                       = 811
	RelationalParserSERIALIZABLE                      = 812
	RelationalParserGEOMETRYCOLLECTION                = 813
	RelationalParserGEOMCOLLECTION                    = 814
	RelationalParserGEOMETRY                          = 815
	RelationalParserLINESTRING                        = 816
	RelationalParserMULTILINESTRING                   = 817
	RelationalParserMULTIPOINT                        = 818
	RelationalParserMULTIPOLYGON                      = 819
	RelationalParserPOINT                             = 820
	RelationalParserPOLYGON                           = 821
	RelationalParserABS                               = 822
	RelationalParserACOS                              = 823
	RelationalParserADDDATE                           = 824
	RelationalParserADDTIME                           = 825
	RelationalParserAES_DECRYPT                       = 826
	RelationalParserAES_ENCRYPT                       = 827
	RelationalParserAREA                              = 828
	RelationalParserASBINARY                          = 829
	RelationalParserASIN                              = 830
	RelationalParserASTEXT                            = 831
	RelationalParserASWKB                             = 832
	RelationalParserASWKT                             = 833
	RelationalParserASYMMETRIC_DECRYPT                = 834
	RelationalParserASYMMETRIC_DERIVE                 = 835
	RelationalParserASYMMETRIC_ENCRYPT                = 836
	RelationalParserASYMMETRIC_SIGN                   = 837
	RelationalParserASYMMETRIC_VERIFY                 = 838
	RelationalParserATAN2                             = 839
	RelationalParserATAN                              = 840
	RelationalParserBENCHMARK                         = 841
	RelationalParserBIN                               = 842
	RelationalParserBIT_COUNT                         = 843
	RelationalParserBIT_LENGTH                        = 844
	RelationalParserBUFFER                            = 845
	RelationalParserCATALOG_NAME                      = 846
	RelationalParserCEIL                              = 847
	RelationalParserCEILING                           = 848
	RelationalParserCENTROID                          = 849
	RelationalParserCHARACTER_LENGTH                  = 850
	RelationalParserCHARSET                           = 851
	RelationalParserCHAR_LENGTH                       = 852
	RelationalParserCOERCIBILITY                      = 853
	RelationalParserCOLLATION                         = 854
	RelationalParserCOMPRESS                          = 855
	RelationalParserCONCAT                            = 856
	RelationalParserCONCAT_WS                         = 857
	RelationalParserCONNECTION_ID                     = 858
	RelationalParserCONV                              = 859
	RelationalParserCONVERT_TZ                        = 860
	RelationalParserCOS                               = 861
	RelationalParserCOSINE_DISTANCE                   = 862
	RelationalParserCOSINE_METRIC                     = 863
	RelationalParserCOT                               = 864
	RelationalParserCRC32                             = 865
	RelationalParserCREATE_ASYMMETRIC_PRIV_KEY        = 866
	RelationalParserCREATE_ASYMMETRIC_PUB_KEY         = 867
	RelationalParserCREATE_DH_PARAMETERS              = 868
	RelationalParserCREATE_DIGEST                     = 869
	RelationalParserCROSSES                           = 870
	RelationalParserDATEDIFF                          = 871
	RelationalParserDATE_FORMAT                       = 872
	RelationalParserDAYNAME                           = 873
	RelationalParserDAYOFMONTH                        = 874
	RelationalParserDAYOFWEEK                         = 875
	RelationalParserDAYOFYEAR                         = 876
	RelationalParserDECODE                            = 877
	RelationalParserDEGREES                           = 878
	RelationalParserDES_DECRYPT                       = 879
	RelationalParserDES_ENCRYPT                       = 880
	RelationalParserDIMENSION                         = 881
	RelationalParserDISJOINT                          = 882
	RelationalParserDOT_PRODUCT_DISTANCE              = 883
	RelationalParserDOT_PRODUCT_METRIC                = 884
	RelationalParserDRY                               = 885
	RelationalParserEF_CONSTRUCTION                   = 886
	RelationalParserEF_SEARCH                         = 887
	RelationalParserELT                               = 888
	RelationalParserENABLE_LONG_ROWS                  = 889
	RelationalParserENCODE                            = 890
	RelationalParserENCRYPT                           = 891
	RelationalParserENDPOINT                          = 892
	RelationalParserENGINE_ATTRIBUTE                  = 893
	RelationalParserENVELOPE                          = 894
	RelationalParserEQUALS                            = 895
	RelationalParserEUCLIDEAN_DISTANCE                = 896
	RelationalParserEUCLIDEAN_METRIC                  = 897
	RelationalParserEUCLIDEAN_SQUARE_DISTANCE         = 898
	RelationalParserEUCLIDEAN_SQUARE_METRIC           = 899
	RelationalParserEXP                               = 900
	RelationalParserEXPORT_SET                        = 901
	RelationalParserEXTERIORRING                      = 902
	RelationalParserEXTRACTVALUE                      = 903
	RelationalParserFIELD                             = 904
	RelationalParserFIND_IN_SET                       = 905
	RelationalParserFLOOR                             = 906
	RelationalParserFORMAT                            = 907
	RelationalParserFOUND_ROWS                        = 908
	RelationalParserFROM_BASE64                       = 909
	RelationalParserFROM_DAYS                         = 910
	RelationalParserFROM_UNIXTIME                     = 911
	RelationalParserGEOMCOLLFROMTEXT                  = 912
	RelationalParserGEOMCOLLFROMWKB                   = 913
	RelationalParserGEOMETRYCOLLECTIONFROMTEXT        = 914
	RelationalParserGEOMETRYCOLLECTIONFROMWKB         = 915
	RelationalParserGEOMETRYFROMTEXT                  = 916
	RelationalParserGEOMETRYFROMWKB                   = 917
	RelationalParserGEOMETRYN                         = 918
	RelationalParserGEOMETRYTYPE                      = 919
	RelationalParserGEOMFROMTEXT                      = 920
	RelationalParserGEOMFROMWKB                       = 921
	RelationalParserGET_FORMAT                        = 922
	RelationalParserGET_LOCK                          = 923
	RelationalParserGLENGTH                           = 924
	RelationalParserGREATEST                          = 925
	RelationalParserGTID_SUBSET                       = 926
	RelationalParserGTID_SUBTRACT                     = 927
	RelationalParserHEX                               = 928
	RelationalParserIFNULL                            = 929
	RelationalParserINET6_ATON                        = 930
	RelationalParserINET6_NTOA                        = 931
	RelationalParserINET_ATON                         = 932
	RelationalParserINET_NTOA                         = 933
	RelationalParserINSTR                             = 934
	RelationalParserINTERIORRINGN                     = 935
	RelationalParserINTERMINGLE_TABLES                = 936
	RelationalParserINTERSECTS                        = 937
	RelationalParserISCLOSED                          = 938
	RelationalParserISEMPTY                           = 939
	RelationalParserISNULL                            = 940
	RelationalParserISSIMPLE                          = 941
	RelationalParserIS_FREE_LOCK                      = 942
	RelationalParserIS_IPV4                           = 943
	RelationalParserIS_IPV4_COMPAT                    = 944
	RelationalParserIS_IPV4_MAPPED                    = 945
	RelationalParserIS_IPV6                           = 946
	RelationalParserIS_USED_LOCK                      = 947
	RelationalParserLAST_INSERT_ID                    = 948
	RelationalParserLCASE                             = 949
	RelationalParserLEAST                             = 950
	RelationalParserLEN                               = 951
	RelationalParserLENGTH                            = 952
	RelationalParserLINEFROMTEXT                      = 953
	RelationalParserLINEFROMWKB                       = 954
	RelationalParserLINESTRINGFROMTEXT                = 955
	RelationalParserLINESTRINGFROMWKB                 = 956
	RelationalParserLN                                = 957
	RelationalParserLOAD_FILE                         = 958
	RelationalParserLOCATE                            = 959
	RelationalParserLOG10                             = 960
	RelationalParserLOG2                              = 961
	RelationalParserLOG                               = 962
	RelationalParserLOWER                             = 963
	RelationalParserLPAD                              = 964
	RelationalParserLTRIM                             = 965
	RelationalParserCONNECTIVITY                      = 966
	RelationalParserMAINTAIN_STATS_PROBABILITY        = 967
	RelationalParserMAKEDATE                          = 968
	RelationalParserMAKETIME                          = 969
	RelationalParserMAKE_SET                          = 970
	RelationalParserMASTER_POS_WAIT                   = 971
	RelationalParserMBRCONTAINS                       = 972
	RelationalParserMBRDISJOINT                       = 973
	RelationalParserMBREQUAL                          = 974
	RelationalParserMBRINTERSECTS                     = 975
	RelationalParserMBROVERLAPS                       = 976
	RelationalParserMBRTOUCHES                        = 977
	RelationalParserMBRWITHIN                         = 978
	RelationalParserMD5                               = 979
	RelationalParserMETRIC                            = 980
	RelationalParserMLINEFROMTEXT                     = 981
	RelationalParserMLINEFROMWKB                      = 982
	RelationalParserMONTHNAME                         = 983
	RelationalParserMPOINTFROMTEXT                    = 984
	RelationalParserMPOINTFROMWKB                     = 985
	RelationalParserMPOLYFROMTEXT                     = 986
	RelationalParserMPOLYFROMWKB                      = 987
	RelationalParserMULTILINESTRINGFROMTEXT           = 988
	RelationalParserMULTILINESTRINGFROMWKB            = 989
	RelationalParserMULTIPOINTFROMTEXT                = 990
	RelationalParserMULTIPOINTFROMWKB                 = 991
	RelationalParserMULTIPOLYGONFROMTEXT              = 992
	RelationalParserMULTIPOLYGONFROMWKB               = 993
	RelationalParserM_MAX                             = 994
	RelationalParserM_MAX_0                           = 995
	RelationalParserNAME_CONST                        = 996
	RelationalParserNULLIF                            = 997
	RelationalParserNUMGEOMETRIES                     = 998
	RelationalParserNUMINTERIORRINGS                  = 999
	RelationalParserNUMPOINTS                         = 1000
	RelationalParserOCT                               = 1001
	RelationalParserOCTET_LENGTH                      = 1002
	RelationalParserORD                               = 1003
	RelationalParserOVERLAPS                          = 1004
	RelationalParserPERIOD_ADD                        = 1005
	RelationalParserPERIOD_DIFF                       = 1006
	RelationalParserPI                                = 1007
	RelationalParserPOINTFROMTEXT                     = 1008
	RelationalParserPOINTFROMWKB                      = 1009
	RelationalParserPOINTN                            = 1010
	RelationalParserPOLYFROMTEXT                      = 1011
	RelationalParserPOLYFROMWKB                       = 1012
	RelationalParserPOLYGONFROMTEXT                   = 1013
	RelationalParserPOLYGONFROMWKB                    = 1014
	RelationalParserPOW                               = 1015
	RelationalParserPOWER                             = 1016
	RelationalParserQUOTE                             = 1017
	RelationalParserRABITQ_NUM_EX_BITS                = 1018
	RelationalParserRADIANS                           = 1019
	RelationalParserRAND                              = 1020
	RelationalParserRANDOM_BYTES                      = 1021
	RelationalParserRELEASE_LOCK                      = 1022
	RelationalParserREVERSE                           = 1023
	RelationalParserROUND                             = 1024
	RelationalParserROW_COUNT                         = 1025
	RelationalParserRPAD                              = 1026
	RelationalParserRTRIM                             = 1027
	RelationalParserRUN                               = 1028
	RelationalParserSAMPLE_VECTOR_STATS_PROBABILITY   = 1029
	RelationalParserSCHEMA_NAME                       = 1030
	RelationalParserSECONDARY_ENGINE_ATTRIBUTE        = 1031
	RelationalParserSEC_TO_TIME                       = 1032
	RelationalParserSESSION_USER                      = 1033
	RelationalParserSHA1                              = 1034
	RelationalParserSHA2                              = 1035
	RelationalParserSHA                               = 1036
	RelationalParserSIGN                              = 1037
	RelationalParserSIN                               = 1038
	RelationalParserSLEEP                             = 1039
	RelationalParserSOUNDEX                           = 1040
	RelationalParserSQL_THREAD_WAIT_AFTER_GTIDS       = 1041
	RelationalParserSQRT                              = 1042
	RelationalParserSRID                              = 1043
	RelationalParserSTARTPOINT                        = 1044
	RelationalParserSTATS_THRESHOLD                   = 1045
	RelationalParserSTORE_ROW_VERSIONS                = 1046
	RelationalParserSTRCMP                            = 1047
	RelationalParserSTR_TO_DATE                       = 1048
	RelationalParserST_AREA                           = 1049
	RelationalParserST_ASBINARY                       = 1050
	RelationalParserST_ASTEXT                         = 1051
	RelationalParserST_ASWKB                          = 1052
	RelationalParserST_ASWKT                          = 1053
	RelationalParserST_BUFFER                         = 1054
	RelationalParserST_CENTROID                       = 1055
	RelationalParserST_CONTAINS                       = 1056
	RelationalParserST_CROSSES                        = 1057
	RelationalParserST_DIFFERENCE                     = 1058
	RelationalParserST_DIMENSION                      = 1059
	RelationalParserST_DISJOINT                       = 1060
	RelationalParserST_DISTANCE                       = 1061
	RelationalParserST_ENDPOINT                       = 1062
	RelationalParserST_ENVELOPE                       = 1063
	RelationalParserST_EQUALS                         = 1064
	RelationalParserST_EXTERIORRING                   = 1065
	RelationalParserST_GEOMCOLLFROMTEXT               = 1066
	RelationalParserST_GEOMCOLLFROMTXT                = 1067
	RelationalParserST_GEOMCOLLFROMWKB                = 1068
	RelationalParserST_GEOMETRYCOLLECTIONFROMTEXT     = 1069
	RelationalParserST_GEOMETRYCOLLECTIONFROMWKB      = 1070
	RelationalParserST_GEOMETRYFROMTEXT               = 1071
	RelationalParserST_GEOMETRYFROMWKB                = 1072
	RelationalParserST_GEOMETRYN                      = 1073
	RelationalParserST_GEOMETRYTYPE                   = 1074
	RelationalParserST_GEOMFROMTEXT                   = 1075
	RelationalParserST_GEOMFROMWKB                    = 1076
	RelationalParserST_INTERIORRINGN                  = 1077
	RelationalParserST_INTERSECTION                   = 1078
	RelationalParserST_INTERSECTS                     = 1079
	RelationalParserST_ISCLOSED                       = 1080
	RelationalParserST_ISEMPTY                        = 1081
	RelationalParserST_ISSIMPLE                       = 1082
	RelationalParserST_LINEFROMTEXT                   = 1083
	RelationalParserST_LINEFROMWKB                    = 1084
	RelationalParserST_LINESTRINGFROMTEXT             = 1085
	RelationalParserST_LINESTRINGFROMWKB              = 1086
	RelationalParserST_NUMGEOMETRIES                  = 1087
	RelationalParserST_NUMINTERIORRING                = 1088
	RelationalParserST_NUMINTERIORRINGS               = 1089
	RelationalParserST_NUMPOINTS                      = 1090
	RelationalParserST_OVERLAPS                       = 1091
	RelationalParserST_POINTFROMTEXT                  = 1092
	RelationalParserST_POINTFROMWKB                   = 1093
	RelationalParserST_POINTN                         = 1094
	RelationalParserST_POLYFROMTEXT                   = 1095
	RelationalParserST_POLYFROMWKB                    = 1096
	RelationalParserST_POLYGONFROMTEXT                = 1097
	RelationalParserST_POLYGONFROMWKB                 = 1098
	RelationalParserST_SRID                           = 1099
	RelationalParserST_STARTPOINT                     = 1100
	RelationalParserST_SYMDIFFERENCE                  = 1101
	RelationalParserST_TOUCHES                        = 1102
	RelationalParserST_UNION                          = 1103
	RelationalParserST_WITHIN                         = 1104
	RelationalParserST_X                              = 1105
	RelationalParserST_Y                              = 1106
	RelationalParserSUBDATE                           = 1107
	RelationalParserSUBSTRING_INDEX                   = 1108
	RelationalParserSUBTIME                           = 1109
	RelationalParserSYSTEM_USER                       = 1110
	RelationalParserTAN                               = 1111
	RelationalParserTIMEDIFF                          = 1112
	RelationalParserTIMESTAMPADD                      = 1113
	RelationalParserTIMESTAMPDIFF                     = 1114
	RelationalParserTIME_FORMAT                       = 1115
	RelationalParserTIME_TO_SEC                       = 1116
	RelationalParserTOUCHES                           = 1117
	RelationalParserTO_BASE64                         = 1118
	RelationalParserTO_DAYS                           = 1119
	RelationalParserTO_SECONDS                        = 1120
	RelationalParserUCASE                             = 1121
	RelationalParserUNCOMPRESS                        = 1122
	RelationalParserUNCOMPRESSED_LENGTH               = 1123
	RelationalParserUNHEX                             = 1124
	RelationalParserUNIX_TIMESTAMP                    = 1125
	RelationalParserUPDATEXML                         = 1126
	RelationalParserUPPER                             = 1127
	RelationalParserUSE_RABITQ                        = 1128
	RelationalParserUUID                              = 1129
	RelationalParserUUID_SHORT                        = 1130
	RelationalParserVALIDATE_PASSWORD_STRENGTH        = 1131
	RelationalParserVERSION                           = 1132
	RelationalParserWAIT_UNTIL_SQL_THREAD_AFTER_GTIDS = 1133
	RelationalParserWEEKDAY                           = 1134
	RelationalParserWEEKOFYEAR                        = 1135
	RelationalParserWEIGHT_STRING                     = 1136
	RelationalParserWITHIN                            = 1137
	RelationalParserX_FUNCTION                        = 1138
	RelationalParserYEARWEEK                          = 1139
	RelationalParserY_FUNCTION                        = 1140
	RelationalParserNAMED_ARG_ASSIGN_TOKEN            = 1141
	RelationalParserVAR_ASSIGN                        = 1142
	RelationalParserPLUS_ASSIGN                       = 1143
	RelationalParserMINUS_ASSIGN                      = 1144
	RelationalParserMULT_ASSIGN                       = 1145
	RelationalParserDIV_ASSIGN                        = 1146
	RelationalParserMOD_ASSIGN                        = 1147
	RelationalParserAND_ASSIGN                        = 1148
	RelationalParserXOR_ASSIGN                        = 1149
	RelationalParserOR_ASSIGN                         = 1150
	RelationalParserSTAR                              = 1151
	RelationalParserDIVIDE                            = 1152
	RelationalParserMODULE                            = 1153
	RelationalParserPLUS                              = 1154
	RelationalParserMINUS                             = 1155
	RelationalParserDIV                               = 1156
	RelationalParserMOD                               = 1157
	RelationalParserEQUAL_SYMBOL                      = 1158
	RelationalParserGREATER_SYMBOL                    = 1159
	RelationalParserLESS_SYMBOL                       = 1160
	RelationalParserEXCLAMATION_SYMBOL                = 1161
	RelationalParserBIT_NOT_OP                        = 1162
	RelationalParserBIT_OR_OP                         = 1163
	RelationalParserBIT_AND_OP                        = 1164
	RelationalParserBIT_XOR_OP                        = 1165
	RelationalParserDOT                               = 1166
	RelationalParserLEFT_ROUND_BRACKET                = 1167
	RelationalParserRIGHT_ROUND_BRACKET               = 1168
	RelationalParserLEFT_CURLY_BRACKET                = 1169
	RelationalParserRIGHT_CURLY_BRACKET               = 1170
	RelationalParserLEFT_SQUARE_BRACKET               = 1171
	RelationalParserRIGHT_SQUARE_BRACKET              = 1172
	RelationalParserCOMMA                             = 1173
	RelationalParserSEMI                              = 1174
	RelationalParserAT_SIGN                           = 1175
	RelationalParserSINGLE_QUOTE_SYMB                 = 1176
	RelationalParserDOUBLE_QUOTE_SYMB                 = 1177
	RelationalParserCOLON_SYMB                        = 1178
	RelationalParserFILESIZE_LITERAL                  = 1179
	RelationalParserSTART_NATIONAL_STRING_LITERAL     = 1180
	RelationalParserSTRING_LITERAL                    = 1181
	RelationalParserDECIMAL_LITERAL                   = 1182
	RelationalParserHEXADECIMAL_LITERAL               = 1183
	RelationalParserBASE64_LITERAL                    = 1184
	RelationalParserREAL_LITERAL                      = 1185
	RelationalParserNULL_SPEC_LITERAL                 = 1186
	RelationalParserBIT_STRING                        = 1187
	RelationalParserSTRING_CHARSET_NAME               = 1188
	RelationalParserQUESTION                          = 1189
	RelationalParserNAMED_PARAMETER                   = 1190
	RelationalParserID                                = 1191
	RelationalParserDOUBLE_QUOTE_ID                   = 1192
	RelationalParserSTRING_USER_NAME                  = 1193
	RelationalParserIP_ADDRESS                        = 1194
	RelationalParserLOCAL_ID                          = 1195
	RelationalParserERROR_RECOGNITION                 = 1196
	RelationalParserBLOCK_COMMENT_OPEN                = 1197
	RelationalParserBLOCK_COMMENT_CLOSE               = 1198
	RelationalParserBLOCK_COMMENT_BODY                = 1199
)

RelationalParser tokens.

View Source
const (
	RelationalParserRULE_root                            = 0
	RelationalParserRULE_statements                      = 1
	RelationalParserRULE_statement                       = 2
	RelationalParserRULE_dmlStatement                    = 3
	RelationalParserRULE_ddlStatement                    = 4
	RelationalParserRULE_transactionStatement            = 5
	RelationalParserRULE_preparedStatement               = 6
	RelationalParserRULE_administrationStatement         = 7
	RelationalParserRULE_utilityStatement                = 8
	RelationalParserRULE_templateClause                  = 9
	RelationalParserRULE_createStatement                 = 10
	RelationalParserRULE_optionsClause                   = 11
	RelationalParserRULE_option                          = 12
	RelationalParserRULE_dropStatement                   = 13
	RelationalParserRULE_structDefinition                = 14
	RelationalParserRULE_tableDefinition                 = 15
	RelationalParserRULE_columnDefinition                = 16
	RelationalParserRULE_functionColumnType              = 17
	RelationalParserRULE_columnType                      = 18
	RelationalParserRULE_primitiveType                   = 19
	RelationalParserRULE_vectorType                      = 20
	RelationalParserRULE_vectorElementType               = 21
	RelationalParserRULE_columnConstraint                = 22
	RelationalParserRULE_primaryKeyDefinition            = 23
	RelationalParserRULE_fullIdList                      = 24
	RelationalParserRULE_enumDefinition                  = 25
	RelationalParserRULE_indexDefinition                 = 26
	RelationalParserRULE_vectorEngine                    = 27
	RelationalParserRULE_indexColumnList                 = 28
	RelationalParserRULE_indexColumnSpec                 = 29
	RelationalParserRULE_includeClause                   = 30
	RelationalParserRULE_indexType                       = 31
	RelationalParserRULE_indexPartitionClause            = 32
	RelationalParserRULE_indexOptions                    = 33
	RelationalParserRULE_indexOption                     = 34
	RelationalParserRULE_vectorIndexOptions              = 35
	RelationalParserRULE_vectorIndexOption               = 36
	RelationalParserRULE_vectorIndexOptionValue          = 37
	RelationalParserRULE_hnswMetric                      = 38
	RelationalParserRULE_indexAttributes                 = 39
	RelationalParserRULE_indexAttribute                  = 40
	RelationalParserRULE_createTempFunction              = 41
	RelationalParserRULE_dropTempFunction                = 42
	RelationalParserRULE_viewDefinition                  = 43
	RelationalParserRULE_storedQueryDefinition           = 44
	RelationalParserRULE_declareBlock                    = 45
	RelationalParserRULE_declaredFunction                = 46
	RelationalParserRULE_tempSqlInvokedFunction          = 47
	RelationalParserRULE_sqlInvokedFunction              = 48
	RelationalParserRULE_functionSpecification           = 49
	RelationalParserRULE_sqlParameterDeclarationList     = 50
	RelationalParserRULE_sqlParameterDeclarations        = 51
	RelationalParserRULE_sqlParameterDeclaration         = 52
	RelationalParserRULE_parameterMode                   = 53
	RelationalParserRULE_returnsClause                   = 54
	RelationalParserRULE_returnsType                     = 55
	RelationalParserRULE_returnsTableType                = 56
	RelationalParserRULE_tableFunctionColumnList         = 57
	RelationalParserRULE_tableFunctionColumnListElement  = 58
	RelationalParserRULE_routineCharacteristics          = 59
	RelationalParserRULE_languageClause                  = 60
	RelationalParserRULE_languageName                    = 61
	RelationalParserRULE_parameterStyle                  = 62
	RelationalParserRULE_deterministicCharacteristic     = 63
	RelationalParserRULE_nullCallClause                  = 64
	RelationalParserRULE_dispatchClause                  = 65
	RelationalParserRULE_routineBody                     = 66
	RelationalParserRULE_charSet                         = 67
	RelationalParserRULE_intervalType                    = 68
	RelationalParserRULE_schemaId                        = 69
	RelationalParserRULE_path                            = 70
	RelationalParserRULE_schemaTemplateId                = 71
	RelationalParserRULE_deleteStatement                 = 72
	RelationalParserRULE_insertStatement                 = 73
	RelationalParserRULE_continuationAtom                = 74
	RelationalParserRULE_selectStatement                 = 75
	RelationalParserRULE_query                           = 76
	RelationalParserRULE_ctes                            = 77
	RelationalParserRULE_traversalOrderClause            = 78
	RelationalParserRULE_namedQuery                      = 79
	RelationalParserRULE_tableFunction                   = 80
	RelationalParserRULE_namedOrUnnamedFunctionArgs      = 81
	RelationalParserRULE_tableFunctionName               = 82
	RelationalParserRULE_queryExpressionBody             = 83
	RelationalParserRULE_insertStatementValue            = 84
	RelationalParserRULE_updatedElement                  = 85
	RelationalParserRULE_assignmentField                 = 86
	RelationalParserRULE_updateStatement                 = 87
	RelationalParserRULE_orderByClause                   = 88
	RelationalParserRULE_orderByExpression               = 89
	RelationalParserRULE_orderClause                     = 90
	RelationalParserRULE_tableSources                    = 91
	RelationalParserRULE_tableSource                     = 92
	RelationalParserRULE_tableSourceItem                 = 93
	RelationalParserRULE_indexHint                       = 94
	RelationalParserRULE_indexHintType                   = 95
	RelationalParserRULE_inlineTableDefinition           = 96
	RelationalParserRULE_joinPart                        = 97
	RelationalParserRULE_queryTerm                       = 98
	RelationalParserRULE_selectElements                  = 99
	RelationalParserRULE_selectElement                   = 100
	RelationalParserRULE_fromClause                      = 101
	RelationalParserRULE_groupByClause                   = 102
	RelationalParserRULE_whereExpr                       = 103
	RelationalParserRULE_havingClause                    = 104
	RelationalParserRULE_qualifyClause                   = 105
	RelationalParserRULE_groupByItem                     = 106
	RelationalParserRULE_limitClause                     = 107
	RelationalParserRULE_limitClauseAtom                 = 108
	RelationalParserRULE_statementOptions                = 109
	RelationalParserRULE_statementOption                 = 110
	RelationalParserRULE_startTransaction                = 111
	RelationalParserRULE_commitStatement                 = 112
	RelationalParserRULE_rollbackStatement               = 113
	RelationalParserRULE_setAutocommitStatement          = 114
	RelationalParserRULE_setTransactionStatement         = 115
	RelationalParserRULE_transactionOption               = 116
	RelationalParserRULE_transactionLevel                = 117
	RelationalParserRULE_prepareStatement                = 118
	RelationalParserRULE_executeStatement                = 119
	RelationalParserRULE_showStatement                   = 120
	RelationalParserRULE_setStatement                    = 121
	RelationalParserRULE_variableClause                  = 122
	RelationalParserRULE_killStatement                   = 123
	RelationalParserRULE_resetStatement                  = 124
	RelationalParserRULE_executeContinuationStatement    = 125
	RelationalParserRULE_copyStatement                   = 126
	RelationalParserRULE_tableIndexes                    = 127
	RelationalParserRULE_loadedTableIndexes              = 128
	RelationalParserRULE_simpleDescribeStatement         = 129
	RelationalParserRULE_fullDescribeStatement           = 130
	RelationalParserRULE_helpStatement                   = 131
	RelationalParserRULE_describeObjectClause            = 132
	RelationalParserRULE_fullId                          = 133
	RelationalParserRULE_tableName                       = 134
	RelationalParserRULE_fullColumnName                  = 135
	RelationalParserRULE_indexColumnName                 = 136
	RelationalParserRULE_charsetName                     = 137
	RelationalParserRULE_collationName                   = 138
	RelationalParserRULE_uid                             = 139
	RelationalParserRULE_simpleId                        = 140
	RelationalParserRULE_nullNotnull                     = 141
	RelationalParserRULE_decimalLiteral                  = 142
	RelationalParserRULE_stringLiteral                   = 143
	RelationalParserRULE_booleanLiteral                  = 144
	RelationalParserRULE_bytesLiteral                    = 145
	RelationalParserRULE_nullLiteral                     = 146
	RelationalParserRULE_constant                        = 147
	RelationalParserRULE_dataType                        = 148
	RelationalParserRULE_collectionOptions               = 149
	RelationalParserRULE_convertedDataType               = 150
	RelationalParserRULE_lengthOneDimension              = 151
	RelationalParserRULE_lengthTwoDimension              = 152
	RelationalParserRULE_lengthTwoOptionalDimension      = 153
	RelationalParserRULE_uidList                         = 154
	RelationalParserRULE_uidWithNestings                 = 155
	RelationalParserRULE_uidListWithNestingsInParens     = 156
	RelationalParserRULE_uidListWithNestings             = 157
	RelationalParserRULE_tables                          = 158
	RelationalParserRULE_indexColumnNames                = 159
	RelationalParserRULE_expressions                     = 160
	RelationalParserRULE_expressionsWithDefaults         = 161
	RelationalParserRULE_recordConstructorForInsert      = 162
	RelationalParserRULE_recordConstructorForInlineTable = 163
	RelationalParserRULE_recordConstructor               = 164
	RelationalParserRULE_ofTypeClause                    = 165
	RelationalParserRULE_arrayConstructor                = 166
	RelationalParserRULE_userVariables                   = 167
	RelationalParserRULE_defaultValue                    = 168
	RelationalParserRULE_currentTimestamp                = 169
	RelationalParserRULE_expressionOrDefault             = 170
	RelationalParserRULE_expressionWithOptionalName      = 171
	RelationalParserRULE_ifExists                        = 172
	RelationalParserRULE_ifNotExists                     = 173
	RelationalParserRULE_functionCall                    = 174
	RelationalParserRULE_specificFunction                = 175
	RelationalParserRULE_caseFuncAlternative             = 176
	RelationalParserRULE_levelsInWeightString            = 177
	RelationalParserRULE_levelInWeightListElement        = 178
	RelationalParserRULE_aggregateWindowedFunction       = 179
	RelationalParserRULE_nullTreatmentClause             = 180
	RelationalParserRULE_aggregateLimitClause            = 181
	RelationalParserRULE_nonAggregateWindowedFunction    = 182
	RelationalParserRULE_overClause                      = 183
	RelationalParserRULE_windowName                      = 184
	RelationalParserRULE_windowSpec                      = 185
	RelationalParserRULE_windowOptionsClause             = 186
	RelationalParserRULE_windowOption                    = 187
	RelationalParserRULE_partitionClause                 = 188
	RelationalParserRULE_scalarFunctionName              = 189
	RelationalParserRULE_userDefinedScalarFunctionName   = 190
	RelationalParserRULE_functionArgs                    = 191
	RelationalParserRULE_functionArg                     = 192
	RelationalParserRULE_namedFunctionArg                = 193
	RelationalParserRULE_expression                      = 194
	RelationalParserRULE_predicate                       = 195
	RelationalParserRULE_expressionAtom                  = 196
	RelationalParserRULE_inList                          = 197
	RelationalParserRULE_preparedStatementParameter      = 198
	RelationalParserRULE_unaryOperator                   = 199
	RelationalParserRULE_comparisonOperator              = 200
	RelationalParserRULE_logicalOperator                 = 201
	RelationalParserRULE_bitOperator                     = 202
	RelationalParserRULE_mathOperator                    = 203
	RelationalParserRULE_jsonOperator                    = 204
	RelationalParserRULE_charsetNameBase                 = 205
	RelationalParserRULE_intervalTypeBase                = 206
	RelationalParserRULE_keywordsCanBeId                 = 207
	RelationalParserRULE_functionNameBase                = 208
	RelationalParserRULE_functionNameKeyword             = 209
)

RelationalParser rules.

View Source
const RelationalLexerIN_BLOCK_COMMENT = 1

RelationalLexerIN_BLOCK_COMMENT is the RelationalLexer mode.

Variables

View Source
var RelationalLexerLexerStaticData struct {
	ChannelNames           []string
	ModeNames              []string
	LiteralNames           []string
	SymbolicNames          []string
	RuleNames              []string
	PredictionContextCache *antlr.PredictionContextCache
	// contains filtered or unexported fields
}
View Source
var RelationalParserParserStaticData struct {
	LiteralNames           []string
	SymbolicNames          []string
	RuleNames              []string
	PredictionContextCache *antlr.PredictionContextCache
	// contains filtered or unexported fields
}

Functions

func InitEmptyAdministrationStatementContext

func InitEmptyAdministrationStatementContext(p *AdministrationStatementContext)

func InitEmptyAggregateLimitClauseContext

func InitEmptyAggregateLimitClauseContext(p *AggregateLimitClauseContext)

func InitEmptyAggregateWindowedFunctionContext

func InitEmptyAggregateWindowedFunctionContext(p *AggregateWindowedFunctionContext)

func InitEmptyArrayConstructorContext

func InitEmptyArrayConstructorContext(p *ArrayConstructorContext)

func InitEmptyAssignmentFieldContext

func InitEmptyAssignmentFieldContext(p *AssignmentFieldContext)

func InitEmptyBitOperatorContext

func InitEmptyBitOperatorContext(p *BitOperatorContext)

func InitEmptyBooleanLiteralContext

func InitEmptyBooleanLiteralContext(p *BooleanLiteralContext)

func InitEmptyBytesLiteralContext

func InitEmptyBytesLiteralContext(p *BytesLiteralContext)

func InitEmptyCaseFuncAlternativeContext

func InitEmptyCaseFuncAlternativeContext(p *CaseFuncAlternativeContext)

func InitEmptyCharSetContext

func InitEmptyCharSetContext(p *CharSetContext)

func InitEmptyCharsetNameBaseContext

func InitEmptyCharsetNameBaseContext(p *CharsetNameBaseContext)

func InitEmptyCharsetNameContext

func InitEmptyCharsetNameContext(p *CharsetNameContext)

func InitEmptyCollationNameContext

func InitEmptyCollationNameContext(p *CollationNameContext)

func InitEmptyCollectionOptionsContext

func InitEmptyCollectionOptionsContext(p *CollectionOptionsContext)

func InitEmptyColumnConstraintContext

func InitEmptyColumnConstraintContext(p *ColumnConstraintContext)

func InitEmptyColumnDefinitionContext

func InitEmptyColumnDefinitionContext(p *ColumnDefinitionContext)

func InitEmptyColumnTypeContext

func InitEmptyColumnTypeContext(p *ColumnTypeContext)

func InitEmptyCommitStatementContext

func InitEmptyCommitStatementContext(p *CommitStatementContext)

func InitEmptyComparisonOperatorContext

func InitEmptyComparisonOperatorContext(p *ComparisonOperatorContext)

func InitEmptyConstantContext

func InitEmptyConstantContext(p *ConstantContext)

func InitEmptyContinuationAtomContext

func InitEmptyContinuationAtomContext(p *ContinuationAtomContext)

func InitEmptyConvertedDataTypeContext

func InitEmptyConvertedDataTypeContext(p *ConvertedDataTypeContext)

func InitEmptyCopyStatementContext

func InitEmptyCopyStatementContext(p *CopyStatementContext)

func InitEmptyCreateStatementContext

func InitEmptyCreateStatementContext(p *CreateStatementContext)

func InitEmptyCreateTempFunctionContext

func InitEmptyCreateTempFunctionContext(p *CreateTempFunctionContext)

func InitEmptyCtesContext

func InitEmptyCtesContext(p *CtesContext)

func InitEmptyCurrentTimestampContext

func InitEmptyCurrentTimestampContext(p *CurrentTimestampContext)

func InitEmptyDataTypeContext

func InitEmptyDataTypeContext(p *DataTypeContext)

func InitEmptyDdlStatementContext

func InitEmptyDdlStatementContext(p *DdlStatementContext)

func InitEmptyDecimalLiteralContext

func InitEmptyDecimalLiteralContext(p *DecimalLiteralContext)

func InitEmptyDeclareBlockContext

func InitEmptyDeclareBlockContext(p *DeclareBlockContext)

func InitEmptyDeclaredFunctionContext

func InitEmptyDeclaredFunctionContext(p *DeclaredFunctionContext)

func InitEmptyDefaultValueContext

func InitEmptyDefaultValueContext(p *DefaultValueContext)

func InitEmptyDeleteStatementContext

func InitEmptyDeleteStatementContext(p *DeleteStatementContext)

func InitEmptyDescribeObjectClauseContext

func InitEmptyDescribeObjectClauseContext(p *DescribeObjectClauseContext)

func InitEmptyDeterministicCharacteristicContext

func InitEmptyDeterministicCharacteristicContext(p *DeterministicCharacteristicContext)

func InitEmptyDispatchClauseContext

func InitEmptyDispatchClauseContext(p *DispatchClauseContext)

func InitEmptyDmlStatementContext

func InitEmptyDmlStatementContext(p *DmlStatementContext)

func InitEmptyDropStatementContext

func InitEmptyDropStatementContext(p *DropStatementContext)

func InitEmptyDropTempFunctionContext

func InitEmptyDropTempFunctionContext(p *DropTempFunctionContext)

func InitEmptyEnumDefinitionContext

func InitEmptyEnumDefinitionContext(p *EnumDefinitionContext)

func InitEmptyExecuteContinuationStatementContext

func InitEmptyExecuteContinuationStatementContext(p *ExecuteContinuationStatementContext)

func InitEmptyExecuteStatementContext

func InitEmptyExecuteStatementContext(p *ExecuteStatementContext)

func InitEmptyExpressionAtomContext

func InitEmptyExpressionAtomContext(p *ExpressionAtomContext)

func InitEmptyExpressionContext

func InitEmptyExpressionContext(p *ExpressionContext)

func InitEmptyExpressionOrDefaultContext

func InitEmptyExpressionOrDefaultContext(p *ExpressionOrDefaultContext)

func InitEmptyExpressionWithOptionalNameContext

func InitEmptyExpressionWithOptionalNameContext(p *ExpressionWithOptionalNameContext)

func InitEmptyExpressionsContext

func InitEmptyExpressionsContext(p *ExpressionsContext)

func InitEmptyExpressionsWithDefaultsContext

func InitEmptyExpressionsWithDefaultsContext(p *ExpressionsWithDefaultsContext)

func InitEmptyFromClauseContext

func InitEmptyFromClauseContext(p *FromClauseContext)

func InitEmptyFullColumnNameContext

func InitEmptyFullColumnNameContext(p *FullColumnNameContext)

func InitEmptyFullDescribeStatementContext

func InitEmptyFullDescribeStatementContext(p *FullDescribeStatementContext)

func InitEmptyFullIdContext

func InitEmptyFullIdContext(p *FullIdContext)

func InitEmptyFullIdListContext

func InitEmptyFullIdListContext(p *FullIdListContext)

func InitEmptyFunctionArgContext

func InitEmptyFunctionArgContext(p *FunctionArgContext)

func InitEmptyFunctionArgsContext

func InitEmptyFunctionArgsContext(p *FunctionArgsContext)

func InitEmptyFunctionCallContext

func InitEmptyFunctionCallContext(p *FunctionCallContext)

func InitEmptyFunctionColumnTypeContext

func InitEmptyFunctionColumnTypeContext(p *FunctionColumnTypeContext)

func InitEmptyFunctionNameBaseContext

func InitEmptyFunctionNameBaseContext(p *FunctionNameBaseContext)

func InitEmptyFunctionNameKeywordContext

func InitEmptyFunctionNameKeywordContext(p *FunctionNameKeywordContext)

func InitEmptyFunctionSpecificationContext

func InitEmptyFunctionSpecificationContext(p *FunctionSpecificationContext)

func InitEmptyGroupByClauseContext

func InitEmptyGroupByClauseContext(p *GroupByClauseContext)

func InitEmptyGroupByItemContext

func InitEmptyGroupByItemContext(p *GroupByItemContext)

func InitEmptyHavingClauseContext

func InitEmptyHavingClauseContext(p *HavingClauseContext)

func InitEmptyHelpStatementContext

func InitEmptyHelpStatementContext(p *HelpStatementContext)

func InitEmptyHnswMetricContext

func InitEmptyHnswMetricContext(p *HnswMetricContext)

func InitEmptyIfExistsContext

func InitEmptyIfExistsContext(p *IfExistsContext)

func InitEmptyIfNotExistsContext

func InitEmptyIfNotExistsContext(p *IfNotExistsContext)

func InitEmptyInListContext

func InitEmptyInListContext(p *InListContext)

func InitEmptyIncludeClauseContext

func InitEmptyIncludeClauseContext(p *IncludeClauseContext)

func InitEmptyIndexAttributeContext

func InitEmptyIndexAttributeContext(p *IndexAttributeContext)

func InitEmptyIndexAttributesContext

func InitEmptyIndexAttributesContext(p *IndexAttributesContext)

func InitEmptyIndexColumnListContext

func InitEmptyIndexColumnListContext(p *IndexColumnListContext)

func InitEmptyIndexColumnNameContext

func InitEmptyIndexColumnNameContext(p *IndexColumnNameContext)

func InitEmptyIndexColumnNamesContext

func InitEmptyIndexColumnNamesContext(p *IndexColumnNamesContext)

func InitEmptyIndexColumnSpecContext

func InitEmptyIndexColumnSpecContext(p *IndexColumnSpecContext)

func InitEmptyIndexDefinitionContext

func InitEmptyIndexDefinitionContext(p *IndexDefinitionContext)

func InitEmptyIndexHintContext

func InitEmptyIndexHintContext(p *IndexHintContext)

func InitEmptyIndexHintTypeContext

func InitEmptyIndexHintTypeContext(p *IndexHintTypeContext)

func InitEmptyIndexOptionContext

func InitEmptyIndexOptionContext(p *IndexOptionContext)

func InitEmptyIndexOptionsContext

func InitEmptyIndexOptionsContext(p *IndexOptionsContext)

func InitEmptyIndexPartitionClauseContext

func InitEmptyIndexPartitionClauseContext(p *IndexPartitionClauseContext)

func InitEmptyIndexTypeContext

func InitEmptyIndexTypeContext(p *IndexTypeContext)

func InitEmptyInlineTableDefinitionContext

func InitEmptyInlineTableDefinitionContext(p *InlineTableDefinitionContext)

func InitEmptyInsertStatementContext

func InitEmptyInsertStatementContext(p *InsertStatementContext)

func InitEmptyInsertStatementValueContext

func InitEmptyInsertStatementValueContext(p *InsertStatementValueContext)

func InitEmptyIntervalTypeBaseContext

func InitEmptyIntervalTypeBaseContext(p *IntervalTypeBaseContext)

func InitEmptyIntervalTypeContext

func InitEmptyIntervalTypeContext(p *IntervalTypeContext)

func InitEmptyJoinPartContext

func InitEmptyJoinPartContext(p *JoinPartContext)

func InitEmptyJsonOperatorContext

func InitEmptyJsonOperatorContext(p *JsonOperatorContext)

func InitEmptyKeywordsCanBeIdContext

func InitEmptyKeywordsCanBeIdContext(p *KeywordsCanBeIdContext)

func InitEmptyKillStatementContext

func InitEmptyKillStatementContext(p *KillStatementContext)

func InitEmptyLanguageClauseContext

func InitEmptyLanguageClauseContext(p *LanguageClauseContext)

func InitEmptyLanguageNameContext

func InitEmptyLanguageNameContext(p *LanguageNameContext)

func InitEmptyLengthOneDimensionContext

func InitEmptyLengthOneDimensionContext(p *LengthOneDimensionContext)

func InitEmptyLengthTwoDimensionContext

func InitEmptyLengthTwoDimensionContext(p *LengthTwoDimensionContext)

func InitEmptyLengthTwoOptionalDimensionContext

func InitEmptyLengthTwoOptionalDimensionContext(p *LengthTwoOptionalDimensionContext)

func InitEmptyLevelInWeightListElementContext

func InitEmptyLevelInWeightListElementContext(p *LevelInWeightListElementContext)

func InitEmptyLevelsInWeightStringContext

func InitEmptyLevelsInWeightStringContext(p *LevelsInWeightStringContext)

func InitEmptyLimitClauseAtomContext

func InitEmptyLimitClauseAtomContext(p *LimitClauseAtomContext)

func InitEmptyLimitClauseContext

func InitEmptyLimitClauseContext(p *LimitClauseContext)

func InitEmptyLoadedTableIndexesContext

func InitEmptyLoadedTableIndexesContext(p *LoadedTableIndexesContext)

func InitEmptyLogicalOperatorContext

func InitEmptyLogicalOperatorContext(p *LogicalOperatorContext)

func InitEmptyMathOperatorContext

func InitEmptyMathOperatorContext(p *MathOperatorContext)

func InitEmptyNamedFunctionArgContext

func InitEmptyNamedFunctionArgContext(p *NamedFunctionArgContext)

func InitEmptyNamedOrUnnamedFunctionArgsContext

func InitEmptyNamedOrUnnamedFunctionArgsContext(p *NamedOrUnnamedFunctionArgsContext)

func InitEmptyNamedQueryContext

func InitEmptyNamedQueryContext(p *NamedQueryContext)

func InitEmptyNonAggregateWindowedFunctionContext

func InitEmptyNonAggregateWindowedFunctionContext(p *NonAggregateWindowedFunctionContext)

func InitEmptyNullCallClauseContext

func InitEmptyNullCallClauseContext(p *NullCallClauseContext)

func InitEmptyNullLiteralContext

func InitEmptyNullLiteralContext(p *NullLiteralContext)

func InitEmptyNullNotnullContext

func InitEmptyNullNotnullContext(p *NullNotnullContext)

func InitEmptyNullTreatmentClauseContext

func InitEmptyNullTreatmentClauseContext(p *NullTreatmentClauseContext)

func InitEmptyOfTypeClauseContext

func InitEmptyOfTypeClauseContext(p *OfTypeClauseContext)

func InitEmptyOptionContext

func InitEmptyOptionContext(p *OptionContext)

func InitEmptyOptionsClauseContext

func InitEmptyOptionsClauseContext(p *OptionsClauseContext)

func InitEmptyOrderByClauseContext

func InitEmptyOrderByClauseContext(p *OrderByClauseContext)

func InitEmptyOrderByExpressionContext

func InitEmptyOrderByExpressionContext(p *OrderByExpressionContext)

func InitEmptyOrderClauseContext

func InitEmptyOrderClauseContext(p *OrderClauseContext)

func InitEmptyOverClauseContext

func InitEmptyOverClauseContext(p *OverClauseContext)

func InitEmptyParameterModeContext

func InitEmptyParameterModeContext(p *ParameterModeContext)

func InitEmptyParameterStyleContext

func InitEmptyParameterStyleContext(p *ParameterStyleContext)

func InitEmptyPartitionClauseContext

func InitEmptyPartitionClauseContext(p *PartitionClauseContext)

func InitEmptyPathContext

func InitEmptyPathContext(p *PathContext)

func InitEmptyPredicateContext

func InitEmptyPredicateContext(p *PredicateContext)

func InitEmptyPrepareStatementContext

func InitEmptyPrepareStatementContext(p *PrepareStatementContext)

func InitEmptyPreparedStatementContext

func InitEmptyPreparedStatementContext(p *PreparedStatementContext)

func InitEmptyPreparedStatementParameterContext

func InitEmptyPreparedStatementParameterContext(p *PreparedStatementParameterContext)

func InitEmptyPrimaryKeyDefinitionContext

func InitEmptyPrimaryKeyDefinitionContext(p *PrimaryKeyDefinitionContext)

func InitEmptyPrimitiveTypeContext

func InitEmptyPrimitiveTypeContext(p *PrimitiveTypeContext)

func InitEmptyQualifyClauseContext

func InitEmptyQualifyClauseContext(p *QualifyClauseContext)

func InitEmptyQueryContext

func InitEmptyQueryContext(p *QueryContext)

func InitEmptyQueryExpressionBodyContext

func InitEmptyQueryExpressionBodyContext(p *QueryExpressionBodyContext)

func InitEmptyQueryTermContext

func InitEmptyQueryTermContext(p *QueryTermContext)

func InitEmptyRecordConstructorContext

func InitEmptyRecordConstructorContext(p *RecordConstructorContext)

func InitEmptyRecordConstructorForInlineTableContext

func InitEmptyRecordConstructorForInlineTableContext(p *RecordConstructorForInlineTableContext)

func InitEmptyRecordConstructorForInsertContext

func InitEmptyRecordConstructorForInsertContext(p *RecordConstructorForInsertContext)

func InitEmptyResetStatementContext

func InitEmptyResetStatementContext(p *ResetStatementContext)

func InitEmptyReturnsClauseContext

func InitEmptyReturnsClauseContext(p *ReturnsClauseContext)

func InitEmptyReturnsTableTypeContext

func InitEmptyReturnsTableTypeContext(p *ReturnsTableTypeContext)

func InitEmptyReturnsTypeContext

func InitEmptyReturnsTypeContext(p *ReturnsTypeContext)

func InitEmptyRollbackStatementContext

func InitEmptyRollbackStatementContext(p *RollbackStatementContext)

func InitEmptyRootContext

func InitEmptyRootContext(p *RootContext)

func InitEmptyRoutineBodyContext

func InitEmptyRoutineBodyContext(p *RoutineBodyContext)

func InitEmptyRoutineCharacteristicsContext

func InitEmptyRoutineCharacteristicsContext(p *RoutineCharacteristicsContext)

func InitEmptyScalarFunctionNameContext

func InitEmptyScalarFunctionNameContext(p *ScalarFunctionNameContext)

func InitEmptySchemaIdContext

func InitEmptySchemaIdContext(p *SchemaIdContext)

func InitEmptySchemaTemplateIdContext

func InitEmptySchemaTemplateIdContext(p *SchemaTemplateIdContext)

func InitEmptySelectElementContext

func InitEmptySelectElementContext(p *SelectElementContext)

func InitEmptySelectElementsContext

func InitEmptySelectElementsContext(p *SelectElementsContext)

func InitEmptySelectStatementContext

func InitEmptySelectStatementContext(p *SelectStatementContext)

func InitEmptySetAutocommitStatementContext

func InitEmptySetAutocommitStatementContext(p *SetAutocommitStatementContext)

func InitEmptySetStatementContext

func InitEmptySetStatementContext(p *SetStatementContext)

func InitEmptySetTransactionStatementContext

func InitEmptySetTransactionStatementContext(p *SetTransactionStatementContext)

func InitEmptyShowStatementContext

func InitEmptyShowStatementContext(p *ShowStatementContext)

func InitEmptySimpleDescribeStatementContext

func InitEmptySimpleDescribeStatementContext(p *SimpleDescribeStatementContext)

func InitEmptySimpleIdContext

func InitEmptySimpleIdContext(p *SimpleIdContext)

func InitEmptySpecificFunctionContext

func InitEmptySpecificFunctionContext(p *SpecificFunctionContext)

func InitEmptySqlInvokedFunctionContext

func InitEmptySqlInvokedFunctionContext(p *SqlInvokedFunctionContext)

func InitEmptySqlParameterDeclarationContext

func InitEmptySqlParameterDeclarationContext(p *SqlParameterDeclarationContext)

func InitEmptySqlParameterDeclarationListContext

func InitEmptySqlParameterDeclarationListContext(p *SqlParameterDeclarationListContext)

func InitEmptySqlParameterDeclarationsContext

func InitEmptySqlParameterDeclarationsContext(p *SqlParameterDeclarationsContext)

func InitEmptyStartTransactionContext

func InitEmptyStartTransactionContext(p *StartTransactionContext)

func InitEmptyStatementContext

func InitEmptyStatementContext(p *StatementContext)

func InitEmptyStatementOptionContext

func InitEmptyStatementOptionContext(p *StatementOptionContext)

func InitEmptyStatementOptionsContext

func InitEmptyStatementOptionsContext(p *StatementOptionsContext)

func InitEmptyStatementsContext

func InitEmptyStatementsContext(p *StatementsContext)

func InitEmptyStoredQueryDefinitionContext

func InitEmptyStoredQueryDefinitionContext(p *StoredQueryDefinitionContext)

func InitEmptyStringLiteralContext

func InitEmptyStringLiteralContext(p *StringLiteralContext)

func InitEmptyStructDefinitionContext

func InitEmptyStructDefinitionContext(p *StructDefinitionContext)

func InitEmptyTableDefinitionContext

func InitEmptyTableDefinitionContext(p *TableDefinitionContext)

func InitEmptyTableFunctionColumnListContext

func InitEmptyTableFunctionColumnListContext(p *TableFunctionColumnListContext)

func InitEmptyTableFunctionColumnListElementContext

func InitEmptyTableFunctionColumnListElementContext(p *TableFunctionColumnListElementContext)

func InitEmptyTableFunctionContext

func InitEmptyTableFunctionContext(p *TableFunctionContext)

func InitEmptyTableFunctionNameContext

func InitEmptyTableFunctionNameContext(p *TableFunctionNameContext)

func InitEmptyTableIndexesContext

func InitEmptyTableIndexesContext(p *TableIndexesContext)

func InitEmptyTableNameContext

func InitEmptyTableNameContext(p *TableNameContext)

func InitEmptyTableSourceContext

func InitEmptyTableSourceContext(p *TableSourceContext)

func InitEmptyTableSourceItemContext

func InitEmptyTableSourceItemContext(p *TableSourceItemContext)

func InitEmptyTableSourcesContext

func InitEmptyTableSourcesContext(p *TableSourcesContext)

func InitEmptyTablesContext

func InitEmptyTablesContext(p *TablesContext)

func InitEmptyTempSqlInvokedFunctionContext

func InitEmptyTempSqlInvokedFunctionContext(p *TempSqlInvokedFunctionContext)

func InitEmptyTemplateClauseContext

func InitEmptyTemplateClauseContext(p *TemplateClauseContext)

func InitEmptyTransactionLevelContext

func InitEmptyTransactionLevelContext(p *TransactionLevelContext)

func InitEmptyTransactionOptionContext

func InitEmptyTransactionOptionContext(p *TransactionOptionContext)

func InitEmptyTransactionStatementContext

func InitEmptyTransactionStatementContext(p *TransactionStatementContext)

func InitEmptyTraversalOrderClauseContext

func InitEmptyTraversalOrderClauseContext(p *TraversalOrderClauseContext)

func InitEmptyUidContext

func InitEmptyUidContext(p *UidContext)

func InitEmptyUidListContext

func InitEmptyUidListContext(p *UidListContext)

func InitEmptyUidListWithNestingsContext

func InitEmptyUidListWithNestingsContext(p *UidListWithNestingsContext)

func InitEmptyUidListWithNestingsInParensContext

func InitEmptyUidListWithNestingsInParensContext(p *UidListWithNestingsInParensContext)

func InitEmptyUidWithNestingsContext

func InitEmptyUidWithNestingsContext(p *UidWithNestingsContext)

func InitEmptyUnaryOperatorContext

func InitEmptyUnaryOperatorContext(p *UnaryOperatorContext)

func InitEmptyUpdateStatementContext

func InitEmptyUpdateStatementContext(p *UpdateStatementContext)

func InitEmptyUpdatedElementContext

func InitEmptyUpdatedElementContext(p *UpdatedElementContext)

func InitEmptyUserDefinedScalarFunctionNameContext

func InitEmptyUserDefinedScalarFunctionNameContext(p *UserDefinedScalarFunctionNameContext)

func InitEmptyUserVariablesContext

func InitEmptyUserVariablesContext(p *UserVariablesContext)

func InitEmptyUtilityStatementContext

func InitEmptyUtilityStatementContext(p *UtilityStatementContext)

func InitEmptyVariableClauseContext

func InitEmptyVariableClauseContext(p *VariableClauseContext)

func InitEmptyVectorElementTypeContext

func InitEmptyVectorElementTypeContext(p *VectorElementTypeContext)

func InitEmptyVectorEngineContext

func InitEmptyVectorEngineContext(p *VectorEngineContext)

func InitEmptyVectorIndexOptionContext

func InitEmptyVectorIndexOptionContext(p *VectorIndexOptionContext)

func InitEmptyVectorIndexOptionValueContext

func InitEmptyVectorIndexOptionValueContext(p *VectorIndexOptionValueContext)

func InitEmptyVectorIndexOptionsContext

func InitEmptyVectorIndexOptionsContext(p *VectorIndexOptionsContext)

func InitEmptyVectorTypeContext

func InitEmptyVectorTypeContext(p *VectorTypeContext)

func InitEmptyViewDefinitionContext

func InitEmptyViewDefinitionContext(p *ViewDefinitionContext)

func InitEmptyWhereExprContext

func InitEmptyWhereExprContext(p *WhereExprContext)

func InitEmptyWindowNameContext

func InitEmptyWindowNameContext(p *WindowNameContext)

func InitEmptyWindowOptionContext

func InitEmptyWindowOptionContext(p *WindowOptionContext)

func InitEmptyWindowOptionsClauseContext

func InitEmptyWindowOptionsClauseContext(p *WindowOptionsClauseContext)

func InitEmptyWindowSpecContext

func InitEmptyWindowSpecContext(p *WindowSpecContext)

func NewRelationalLexerATN

func NewRelationalLexerATN() *antlr.ATN

NewRelationalLexerATN deserializes a private copy of the lexer's ATN. The ANTLR runtime takes the ATN's locks for every DFA edge it adds, so lexers sharing one ATN serialize on them; a copy per prediction-state lease does not.

func NewRelationalParserATN

func NewRelationalParserATN() *antlr.ATN

NewRelationalParserATN is NewRelationalLexerATN for the parser.

func RelationalLexerInit

func RelationalLexerInit()

RelationalLexerInit initializes any static state used to implement RelationalLexer. By default the static state used to implement the lexer is lazily initialized during the first call to NewRelationalLexer(). You can call this function if you wish to initialize the static state ahead of time.

func RelationalParserInit

func RelationalParserInit()

RelationalParserInit initializes any static state used to implement RelationalParser. By default the static state used to implement the parser is lazily initialized during the first call to NewRelationalParser(). You can call this function if you wish to initialize the static state ahead of time.

Types

type AdministrationStatementContext

type AdministrationStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAdministrationStatementContext

func NewAdministrationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdministrationStatementContext

func NewEmptyAdministrationStatementContext

func NewEmptyAdministrationStatementContext() *AdministrationStatementContext

func (*AdministrationStatementContext) Accept

func (s *AdministrationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AdministrationStatementContext) CopyStatement

func (*AdministrationStatementContext) EnterRule

func (*AdministrationStatementContext) ExecuteContinuationStatement

func (s *AdministrationStatementContext) ExecuteContinuationStatement() IExecuteContinuationStatementContext

func (*AdministrationStatementContext) ExitRule

func (*AdministrationStatementContext) GetParser

func (*AdministrationStatementContext) GetRuleContext

func (s *AdministrationStatementContext) GetRuleContext() antlr.RuleContext

func (*AdministrationStatementContext) IsAdministrationStatementContext

func (*AdministrationStatementContext) IsAdministrationStatementContext()

func (*AdministrationStatementContext) KillStatement

func (*AdministrationStatementContext) ResetStatement

func (*AdministrationStatementContext) SetStatement

func (*AdministrationStatementContext) ShowStatement

func (*AdministrationStatementContext) ToStringTree

func (s *AdministrationStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type AggregateFunctionCallContext

type AggregateFunctionCallContext struct {
	FunctionCallContext
}

func NewAggregateFunctionCallContext

func NewAggregateFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AggregateFunctionCallContext

func (*AggregateFunctionCallContext) Accept

func (s *AggregateFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AggregateFunctionCallContext) AggregateWindowedFunction

func (s *AggregateFunctionCallContext) AggregateWindowedFunction() IAggregateWindowedFunctionContext

func (*AggregateFunctionCallContext) EnterRule

func (s *AggregateFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*AggregateFunctionCallContext) ExitRule

func (*AggregateFunctionCallContext) GetRuleContext

func (s *AggregateFunctionCallContext) GetRuleContext() antlr.RuleContext

type AggregateLimitClauseContext

type AggregateLimitClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAggregateLimitClauseContext

func NewAggregateLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AggregateLimitClauseContext

func NewEmptyAggregateLimitClauseContext

func NewEmptyAggregateLimitClauseContext() *AggregateLimitClauseContext

func (*AggregateLimitClauseContext) Accept

func (s *AggregateLimitClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AggregateLimitClauseContext) DecimalLiteral

func (*AggregateLimitClauseContext) EnterRule

func (s *AggregateLimitClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*AggregateLimitClauseContext) ExitRule

func (s *AggregateLimitClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*AggregateLimitClauseContext) GetLimit

func (*AggregateLimitClauseContext) GetParser

func (s *AggregateLimitClauseContext) GetParser() antlr.Parser

func (*AggregateLimitClauseContext) GetRuleContext

func (s *AggregateLimitClauseContext) GetRuleContext() antlr.RuleContext

func (*AggregateLimitClauseContext) IsAggregateLimitClauseContext

func (*AggregateLimitClauseContext) IsAggregateLimitClauseContext()

func (*AggregateLimitClauseContext) LIMIT

func (*AggregateLimitClauseContext) SetLimit

func (*AggregateLimitClauseContext) ToStringTree

func (s *AggregateLimitClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type AggregateWindowedFunctionContext

type AggregateWindowedFunctionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAggregateWindowedFunctionContext

func NewAggregateWindowedFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AggregateWindowedFunctionContext

func NewEmptyAggregateWindowedFunctionContext

func NewEmptyAggregateWindowedFunctionContext() *AggregateWindowedFunctionContext

func (*AggregateWindowedFunctionContext) ALL

func (*AggregateWindowedFunctionContext) ARRAY_AGG

func (*AggregateWindowedFunctionContext) AVG

func (*AggregateWindowedFunctionContext) Accept

func (s *AggregateWindowedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AggregateWindowedFunctionContext) AggregateLimitClause

func (*AggregateWindowedFunctionContext) AllCOMMA

func (*AggregateWindowedFunctionContext) AllOrderByExpression

func (s *AggregateWindowedFunctionContext) AllOrderByExpression() []IOrderByExpressionContext

func (*AggregateWindowedFunctionContext) BITMAP_CONSTRUCT_AGG

func (s *AggregateWindowedFunctionContext) BITMAP_CONSTRUCT_AGG() antlr.TerminalNode

func (*AggregateWindowedFunctionContext) BIT_AND

func (*AggregateWindowedFunctionContext) BIT_OR

func (*AggregateWindowedFunctionContext) BIT_XOR

func (*AggregateWindowedFunctionContext) BY

func (*AggregateWindowedFunctionContext) COMMA

func (*AggregateWindowedFunctionContext) COUNT

func (*AggregateWindowedFunctionContext) DISTINCT

func (*AggregateWindowedFunctionContext) EnterRule

func (*AggregateWindowedFunctionContext) ExitRule

func (*AggregateWindowedFunctionContext) FunctionArg

func (*AggregateWindowedFunctionContext) FunctionArgs

func (*AggregateWindowedFunctionContext) GROUP_CONCAT

func (*AggregateWindowedFunctionContext) GetAggregator

func (s *AggregateWindowedFunctionContext) GetAggregator() antlr.Token

func (*AggregateWindowedFunctionContext) GetFunctionName

func (s *AggregateWindowedFunctionContext) GetFunctionName() antlr.Token

func (*AggregateWindowedFunctionContext) GetParser

func (*AggregateWindowedFunctionContext) GetRuleContext

func (*AggregateWindowedFunctionContext) GetSeparator

func (s *AggregateWindowedFunctionContext) GetSeparator() antlr.Token

func (*AggregateWindowedFunctionContext) GetStarArg

func (*AggregateWindowedFunctionContext) IsAggregateWindowedFunctionContext

func (*AggregateWindowedFunctionContext) IsAggregateWindowedFunctionContext()

func (*AggregateWindowedFunctionContext) LEFT_ROUND_BRACKET

func (s *AggregateWindowedFunctionContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*AggregateWindowedFunctionContext) MAX

func (*AggregateWindowedFunctionContext) MAX_EVER

func (*AggregateWindowedFunctionContext) MIN

func (*AggregateWindowedFunctionContext) MIN_EVER

func (*AggregateWindowedFunctionContext) NullTreatmentClause

func (*AggregateWindowedFunctionContext) ORDER

func (*AggregateWindowedFunctionContext) OrderByClause

func (*AggregateWindowedFunctionContext) OrderByExpression

func (*AggregateWindowedFunctionContext) OverClause

func (*AggregateWindowedFunctionContext) RIGHT_ROUND_BRACKET

func (s *AggregateWindowedFunctionContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*AggregateWindowedFunctionContext) SEPARATOR

func (*AggregateWindowedFunctionContext) STAR

func (*AggregateWindowedFunctionContext) STD

func (*AggregateWindowedFunctionContext) STDDEV

func (*AggregateWindowedFunctionContext) STDDEV_POP

func (*AggregateWindowedFunctionContext) STDDEV_SAMP

func (*AggregateWindowedFunctionContext) STRING_LITERAL

func (*AggregateWindowedFunctionContext) SUM

func (*AggregateWindowedFunctionContext) SetAggregator

func (s *AggregateWindowedFunctionContext) SetAggregator(v antlr.Token)

func (*AggregateWindowedFunctionContext) SetFunctionName

func (s *AggregateWindowedFunctionContext) SetFunctionName(v antlr.Token)

func (*AggregateWindowedFunctionContext) SetSeparator

func (s *AggregateWindowedFunctionContext) SetSeparator(v antlr.Token)

func (*AggregateWindowedFunctionContext) SetStarArg

func (s *AggregateWindowedFunctionContext) SetStarArg(v antlr.Token)

func (*AggregateWindowedFunctionContext) ToStringTree

func (s *AggregateWindowedFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*AggregateWindowedFunctionContext) VARIANCE

func (*AggregateWindowedFunctionContext) VAR_POP

func (*AggregateWindowedFunctionContext) VAR_SAMP

type ArrayConstructorContext

type ArrayConstructorContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrayConstructorContext

func NewArrayConstructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayConstructorContext

func NewEmptyArrayConstructorContext

func NewEmptyArrayConstructorContext() *ArrayConstructorContext

func (*ArrayConstructorContext) Accept

func (s *ArrayConstructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrayConstructorContext) EnterRule

func (s *ArrayConstructorContext) EnterRule(listener antlr.ParseTreeListener)

func (*ArrayConstructorContext) ExitRule

func (s *ArrayConstructorContext) ExitRule(listener antlr.ParseTreeListener)

func (*ArrayConstructorContext) Expressions

func (*ArrayConstructorContext) GetParser

func (s *ArrayConstructorContext) GetParser() antlr.Parser

func (*ArrayConstructorContext) GetRuleContext

func (s *ArrayConstructorContext) GetRuleContext() antlr.RuleContext

func (*ArrayConstructorContext) IsArrayConstructorContext

func (*ArrayConstructorContext) IsArrayConstructorContext()

func (*ArrayConstructorContext) LEFT_SQUARE_BRACKET

func (s *ArrayConstructorContext) LEFT_SQUARE_BRACKET() antlr.TerminalNode

func (*ArrayConstructorContext) RIGHT_SQUARE_BRACKET

func (s *ArrayConstructorContext) RIGHT_SQUARE_BRACKET() antlr.TerminalNode

func (*ArrayConstructorContext) ToStringTree

func (s *ArrayConstructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ArrayConstructorExpressionAtomContext

type ArrayConstructorExpressionAtomContext struct {
	ExpressionAtomContext
}

func (*ArrayConstructorExpressionAtomContext) Accept

func (s *ArrayConstructorExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrayConstructorExpressionAtomContext) ArrayConstructor

func (*ArrayConstructorExpressionAtomContext) EnterRule

func (*ArrayConstructorExpressionAtomContext) ExitRule

func (*ArrayConstructorExpressionAtomContext) GetRuleContext

type AssignmentFieldContext

type AssignmentFieldContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAssignmentFieldContext

func NewAssignmentFieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AssignmentFieldContext

func NewEmptyAssignmentFieldContext

func NewEmptyAssignmentFieldContext() *AssignmentFieldContext

func (*AssignmentFieldContext) Accept

func (s *AssignmentFieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AssignmentFieldContext) EnterRule

func (s *AssignmentFieldContext) EnterRule(listener antlr.ParseTreeListener)

func (*AssignmentFieldContext) ExitRule

func (s *AssignmentFieldContext) ExitRule(listener antlr.ParseTreeListener)

func (*AssignmentFieldContext) GetParser

func (s *AssignmentFieldContext) GetParser() antlr.Parser

func (*AssignmentFieldContext) GetRuleContext

func (s *AssignmentFieldContext) GetRuleContext() antlr.RuleContext

func (*AssignmentFieldContext) IsAssignmentFieldContext

func (*AssignmentFieldContext) IsAssignmentFieldContext()

func (*AssignmentFieldContext) LOCAL_ID

func (*AssignmentFieldContext) ToStringTree

func (s *AssignmentFieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*AssignmentFieldContext) Uid

type AtomTableItemContext

type AtomTableItemContext struct {
	TableSourceItemContext
	// contains filtered or unexported fields
}

func NewAtomTableItemContext

func NewAtomTableItemContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AtomTableItemContext

func (*AtomTableItemContext) AS

func (*AtomTableItemContext) AT

func (*AtomTableItemContext) Accept

func (s *AtomTableItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AtomTableItemContext) AllCOMMA

func (s *AtomTableItemContext) AllCOMMA() []antlr.TerminalNode

func (*AtomTableItemContext) AllIndexHint

func (s *AtomTableItemContext) AllIndexHint() []IIndexHintContext

func (*AtomTableItemContext) AllUid

func (s *AtomTableItemContext) AllUid() []IUidContext

func (*AtomTableItemContext) COMMA

func (*AtomTableItemContext) EnterRule

func (s *AtomTableItemContext) EnterRule(listener antlr.ParseTreeListener)

func (*AtomTableItemContext) ExitRule

func (s *AtomTableItemContext) ExitRule(listener antlr.ParseTreeListener)

func (*AtomTableItemContext) GetAlias

func (s *AtomTableItemContext) GetAlias() IUidContext

func (*AtomTableItemContext) GetAtAlias

func (s *AtomTableItemContext) GetAtAlias() IUidContext

func (*AtomTableItemContext) GetRuleContext

func (s *AtomTableItemContext) GetRuleContext() antlr.RuleContext

func (*AtomTableItemContext) IndexHint

func (s *AtomTableItemContext) IndexHint(i int) IIndexHintContext

func (*AtomTableItemContext) SetAlias

func (s *AtomTableItemContext) SetAlias(v IUidContext)

func (*AtomTableItemContext) SetAtAlias

func (s *AtomTableItemContext) SetAtAlias(v IUidContext)

func (*AtomTableItemContext) TableName

func (s *AtomTableItemContext) TableName() ITableNameContext

func (*AtomTableItemContext) Uid

type BaseRelationalParserListener

type BaseRelationalParserListener struct{}

BaseRelationalParserListener is a complete listener for a parse tree produced by RelationalParser.

func (*BaseRelationalParserListener) EnterAdministrationStatement

func (s *BaseRelationalParserListener) EnterAdministrationStatement(ctx *AdministrationStatementContext)

EnterAdministrationStatement is called when production administrationStatement is entered.

func (*BaseRelationalParserListener) EnterAggregateFunctionCall

func (s *BaseRelationalParserListener) EnterAggregateFunctionCall(ctx *AggregateFunctionCallContext)

EnterAggregateFunctionCall is called when production aggregateFunctionCall is entered.

func (*BaseRelationalParserListener) EnterAggregateLimitClause

func (s *BaseRelationalParserListener) EnterAggregateLimitClause(ctx *AggregateLimitClauseContext)

EnterAggregateLimitClause is called when production aggregateLimitClause is entered.

func (*BaseRelationalParserListener) EnterAggregateWindowedFunction

func (s *BaseRelationalParserListener) EnterAggregateWindowedFunction(ctx *AggregateWindowedFunctionContext)

EnterAggregateWindowedFunction is called when production aggregateWindowedFunction is entered.

func (*BaseRelationalParserListener) EnterArrayConstructor

func (s *BaseRelationalParserListener) EnterArrayConstructor(ctx *ArrayConstructorContext)

EnterArrayConstructor is called when production arrayConstructor is entered.

func (*BaseRelationalParserListener) EnterArrayConstructorExpressionAtom

func (s *BaseRelationalParserListener) EnterArrayConstructorExpressionAtom(ctx *ArrayConstructorExpressionAtomContext)

EnterArrayConstructorExpressionAtom is called when production arrayConstructorExpressionAtom is entered.

func (*BaseRelationalParserListener) EnterAssignmentField

func (s *BaseRelationalParserListener) EnterAssignmentField(ctx *AssignmentFieldContext)

EnterAssignmentField is called when production assignmentField is entered.

func (*BaseRelationalParserListener) EnterAtomTableItem

func (s *BaseRelationalParserListener) EnterAtomTableItem(ctx *AtomTableItemContext)

EnterAtomTableItem is called when production atomTableItem is entered.

func (*BaseRelationalParserListener) EnterBetweenComparisonPredicate

func (s *BaseRelationalParserListener) EnterBetweenComparisonPredicate(ctx *BetweenComparisonPredicateContext)

EnterBetweenComparisonPredicate is called when production betweenComparisonPredicate is entered.

func (*BaseRelationalParserListener) EnterBinaryComparisonPredicate

func (s *BaseRelationalParserListener) EnterBinaryComparisonPredicate(ctx *BinaryComparisonPredicateContext)

EnterBinaryComparisonPredicate is called when production binaryComparisonPredicate is entered.

func (*BaseRelationalParserListener) EnterBitExpressionAtom

func (s *BaseRelationalParserListener) EnterBitExpressionAtom(ctx *BitExpressionAtomContext)

EnterBitExpressionAtom is called when production bitExpressionAtom is entered.

func (*BaseRelationalParserListener) EnterBitOperator

func (s *BaseRelationalParserListener) EnterBitOperator(ctx *BitOperatorContext)

EnterBitOperator is called when production bitOperator is entered.

func (*BaseRelationalParserListener) EnterBitStringConstant

func (s *BaseRelationalParserListener) EnterBitStringConstant(ctx *BitStringConstantContext)

EnterBitStringConstant is called when production bitStringConstant is entered.

func (*BaseRelationalParserListener) EnterBooleanConstant

func (s *BaseRelationalParserListener) EnterBooleanConstant(ctx *BooleanConstantContext)

EnterBooleanConstant is called when production booleanConstant is entered.

func (*BaseRelationalParserListener) EnterBooleanLiteral

func (s *BaseRelationalParserListener) EnterBooleanLiteral(ctx *BooleanLiteralContext)

EnterBooleanLiteral is called when production booleanLiteral is entered.

func (*BaseRelationalParserListener) EnterBytesConstant

func (s *BaseRelationalParserListener) EnterBytesConstant(ctx *BytesConstantContext)

EnterBytesConstant is called when production bytesConstant is entered.

func (*BaseRelationalParserListener) EnterBytesLiteral

func (s *BaseRelationalParserListener) EnterBytesLiteral(ctx *BytesLiteralContext)

EnterBytesLiteral is called when production bytesLiteral is entered.

func (*BaseRelationalParserListener) EnterCaseExpressionFunctionCall

func (s *BaseRelationalParserListener) EnterCaseExpressionFunctionCall(ctx *CaseExpressionFunctionCallContext)

EnterCaseExpressionFunctionCall is called when production caseExpressionFunctionCall is entered.

func (*BaseRelationalParserListener) EnterCaseFuncAlternative

func (s *BaseRelationalParserListener) EnterCaseFuncAlternative(ctx *CaseFuncAlternativeContext)

EnterCaseFuncAlternative is called when production caseFuncAlternative is entered.

func (*BaseRelationalParserListener) EnterCaseFunctionCall

func (s *BaseRelationalParserListener) EnterCaseFunctionCall(ctx *CaseFunctionCallContext)

EnterCaseFunctionCall is called when production caseFunctionCall is entered.

func (*BaseRelationalParserListener) EnterCharFunctionCall

func (s *BaseRelationalParserListener) EnterCharFunctionCall(ctx *CharFunctionCallContext)

EnterCharFunctionCall is called when production charFunctionCall is entered.

func (*BaseRelationalParserListener) EnterCharSet

func (s *BaseRelationalParserListener) EnterCharSet(ctx *CharSetContext)

EnterCharSet is called when production charSet is entered.

func (*BaseRelationalParserListener) EnterCharsetName

func (s *BaseRelationalParserListener) EnterCharsetName(ctx *CharsetNameContext)

EnterCharsetName is called when production charsetName is entered.

func (*BaseRelationalParserListener) EnterCharsetNameBase

func (s *BaseRelationalParserListener) EnterCharsetNameBase(ctx *CharsetNameBaseContext)

EnterCharsetNameBase is called when production charsetNameBase is entered.

func (*BaseRelationalParserListener) EnterCollationName

func (s *BaseRelationalParserListener) EnterCollationName(ctx *CollationNameContext)

EnterCollationName is called when production collationName is entered.

func (*BaseRelationalParserListener) EnterCollectionDataType

func (s *BaseRelationalParserListener) EnterCollectionDataType(ctx *CollectionDataTypeContext)

EnterCollectionDataType is called when production collectionDataType is entered.

func (*BaseRelationalParserListener) EnterCollectionOptions

func (s *BaseRelationalParserListener) EnterCollectionOptions(ctx *CollectionOptionsContext)

EnterCollectionOptions is called when production collectionOptions is entered.

func (*BaseRelationalParserListener) EnterColumnDefinition

func (s *BaseRelationalParserListener) EnterColumnDefinition(ctx *ColumnDefinitionContext)

EnterColumnDefinition is called when production columnDefinition is entered.

func (*BaseRelationalParserListener) EnterColumnType

func (s *BaseRelationalParserListener) EnterColumnType(ctx *ColumnTypeContext)

EnterColumnType is called when production columnType is entered.

func (*BaseRelationalParserListener) EnterCommitStatement

func (s *BaseRelationalParserListener) EnterCommitStatement(ctx *CommitStatementContext)

EnterCommitStatement is called when production commitStatement is entered.

func (*BaseRelationalParserListener) EnterComparisonOperator

func (s *BaseRelationalParserListener) EnterComparisonOperator(ctx *ComparisonOperatorContext)

EnterComparisonOperator is called when production comparisonOperator is entered.

func (*BaseRelationalParserListener) EnterConstantExpressionAtom

func (s *BaseRelationalParserListener) EnterConstantExpressionAtom(ctx *ConstantExpressionAtomContext)

EnterConstantExpressionAtom is called when production constantExpressionAtom is entered.

func (*BaseRelationalParserListener) EnterContinuationAtom

func (s *BaseRelationalParserListener) EnterContinuationAtom(ctx *ContinuationAtomContext)

EnterContinuationAtom is called when production continuationAtom is entered.

func (*BaseRelationalParserListener) EnterConvertedDataType

func (s *BaseRelationalParserListener) EnterConvertedDataType(ctx *ConvertedDataTypeContext)

EnterConvertedDataType is called when production convertedDataType is entered.

func (*BaseRelationalParserListener) EnterCopyExportStatement

func (s *BaseRelationalParserListener) EnterCopyExportStatement(ctx *CopyExportStatementContext)

EnterCopyExportStatement is called when production copyExportStatement is entered.

func (*BaseRelationalParserListener) EnterCopyImportStatement

func (s *BaseRelationalParserListener) EnterCopyImportStatement(ctx *CopyImportStatementContext)

EnterCopyImportStatement is called when production copyImportStatement is entered.

func (*BaseRelationalParserListener) EnterCreateDatabaseStatement

func (s *BaseRelationalParserListener) EnterCreateDatabaseStatement(ctx *CreateDatabaseStatementContext)

EnterCreateDatabaseStatement is called when production createDatabaseStatement is entered.

func (*BaseRelationalParserListener) EnterCreateSchemaStatement

func (s *BaseRelationalParserListener) EnterCreateSchemaStatement(ctx *CreateSchemaStatementContext)

EnterCreateSchemaStatement is called when production createSchemaStatement is entered.

func (*BaseRelationalParserListener) EnterCreateSchemaTemplateStatement

func (s *BaseRelationalParserListener) EnterCreateSchemaTemplateStatement(ctx *CreateSchemaTemplateStatementContext)

EnterCreateSchemaTemplateStatement is called when production createSchemaTemplateStatement is entered.

func (*BaseRelationalParserListener) EnterCreateTempFunction

func (s *BaseRelationalParserListener) EnterCreateTempFunction(ctx *CreateTempFunctionContext)

EnterCreateTempFunction is called when production createTempFunction is entered.

func (*BaseRelationalParserListener) EnterCtes

func (s *BaseRelationalParserListener) EnterCtes(ctx *CtesContext)

EnterCtes is called when production ctes is entered.

func (*BaseRelationalParserListener) EnterCurrentTimestamp

func (s *BaseRelationalParserListener) EnterCurrentTimestamp(ctx *CurrentTimestampContext)

EnterCurrentTimestamp is called when production currentTimestamp is entered.

func (*BaseRelationalParserListener) EnterDataTypeFunctionCall

func (s *BaseRelationalParserListener) EnterDataTypeFunctionCall(ctx *DataTypeFunctionCallContext)

EnterDataTypeFunctionCall is called when production dataTypeFunctionCall is entered.

func (*BaseRelationalParserListener) EnterDdlStatement

func (s *BaseRelationalParserListener) EnterDdlStatement(ctx *DdlStatementContext)

EnterDdlStatement is called when production ddlStatement is entered.

func (*BaseRelationalParserListener) EnterDecimalConstant

func (s *BaseRelationalParserListener) EnterDecimalConstant(ctx *DecimalConstantContext)

EnterDecimalConstant is called when production decimalConstant is entered.

func (*BaseRelationalParserListener) EnterDecimalLiteral

func (s *BaseRelationalParserListener) EnterDecimalLiteral(ctx *DecimalLiteralContext)

EnterDecimalLiteral is called when production decimalLiteral is entered.

func (*BaseRelationalParserListener) EnterDeclareBlock

func (s *BaseRelationalParserListener) EnterDeclareBlock(ctx *DeclareBlockContext)

EnterDeclareBlock is called when production declareBlock is entered.

func (*BaseRelationalParserListener) EnterDeclaredFunction

func (s *BaseRelationalParserListener) EnterDeclaredFunction(ctx *DeclaredFunctionContext)

EnterDeclaredFunction is called when production declaredFunction is entered.

func (*BaseRelationalParserListener) EnterDefaultValue

func (s *BaseRelationalParserListener) EnterDefaultValue(ctx *DefaultValueContext)

EnterDefaultValue is called when production defaultValue is entered.

func (*BaseRelationalParserListener) EnterDeleteStatement

func (s *BaseRelationalParserListener) EnterDeleteStatement(ctx *DeleteStatementContext)

EnterDeleteStatement is called when production deleteStatement is entered.

func (*BaseRelationalParserListener) EnterDescribeConnection

func (s *BaseRelationalParserListener) EnterDescribeConnection(ctx *DescribeConnectionContext)

EnterDescribeConnection is called when production describeConnection is entered.

func (*BaseRelationalParserListener) EnterDescribeStatements

func (s *BaseRelationalParserListener) EnterDescribeStatements(ctx *DescribeStatementsContext)

EnterDescribeStatements is called when production describeStatements is entered.

func (*BaseRelationalParserListener) EnterDeterministicCharacteristic

func (s *BaseRelationalParserListener) EnterDeterministicCharacteristic(ctx *DeterministicCharacteristicContext)

EnterDeterministicCharacteristic is called when production deterministicCharacteristic is entered.

func (*BaseRelationalParserListener) EnterDimensionDataType

func (s *BaseRelationalParserListener) EnterDimensionDataType(ctx *DimensionDataTypeContext)

EnterDimensionDataType is called when production dimensionDataType is entered.

func (*BaseRelationalParserListener) EnterDispatchClause

func (s *BaseRelationalParserListener) EnterDispatchClause(ctx *DispatchClauseContext)

EnterDispatchClause is called when production dispatchClause is entered.

func (*BaseRelationalParserListener) EnterDmlStatement

func (s *BaseRelationalParserListener) EnterDmlStatement(ctx *DmlStatementContext)

EnterDmlStatement is called when production dmlStatement is entered.

func (*BaseRelationalParserListener) EnterDropDatabaseStatement

func (s *BaseRelationalParserListener) EnterDropDatabaseStatement(ctx *DropDatabaseStatementContext)

EnterDropDatabaseStatement is called when production dropDatabaseStatement is entered.

func (*BaseRelationalParserListener) EnterDropSchemaStatement

func (s *BaseRelationalParserListener) EnterDropSchemaStatement(ctx *DropSchemaStatementContext)

EnterDropSchemaStatement is called when production dropSchemaStatement is entered.

func (*BaseRelationalParserListener) EnterDropSchemaTemplateStatement

func (s *BaseRelationalParserListener) EnterDropSchemaTemplateStatement(ctx *DropSchemaTemplateStatementContext)

EnterDropSchemaTemplateStatement is called when production dropSchemaTemplateStatement is entered.

func (*BaseRelationalParserListener) EnterDropTempFunction

func (s *BaseRelationalParserListener) EnterDropTempFunction(ctx *DropTempFunctionContext)

EnterDropTempFunction is called when production dropTempFunction is entered.

func (*BaseRelationalParserListener) EnterEnumDefinition

func (s *BaseRelationalParserListener) EnterEnumDefinition(ctx *EnumDefinitionContext)

EnterEnumDefinition is called when production enumDefinition is entered.

func (*BaseRelationalParserListener) EnterEveryRule

func (s *BaseRelationalParserListener) EnterEveryRule(ctx antlr.ParserRuleContext)

EnterEveryRule is called when any rule is entered.

func (*BaseRelationalParserListener) EnterExecuteContinuationStatement

func (s *BaseRelationalParserListener) EnterExecuteContinuationStatement(ctx *ExecuteContinuationStatementContext)

EnterExecuteContinuationStatement is called when production executeContinuationStatement is entered.

func (*BaseRelationalParserListener) EnterExecuteStatement

func (s *BaseRelationalParserListener) EnterExecuteStatement(ctx *ExecuteStatementContext)

EnterExecuteStatement is called when production executeStatement is entered.

func (*BaseRelationalParserListener) EnterExistsExpressionAtom

func (s *BaseRelationalParserListener) EnterExistsExpressionAtom(ctx *ExistsExpressionAtomContext)

EnterExistsExpressionAtom is called when production existsExpressionAtom is entered.

func (*BaseRelationalParserListener) EnterExpressionOrDefault

func (s *BaseRelationalParserListener) EnterExpressionOrDefault(ctx *ExpressionOrDefaultContext)

EnterExpressionOrDefault is called when production expressionOrDefault is entered.

func (*BaseRelationalParserListener) EnterExpressionWithOptionalName

func (s *BaseRelationalParserListener) EnterExpressionWithOptionalName(ctx *ExpressionWithOptionalNameContext)

EnterExpressionWithOptionalName is called when production expressionWithOptionalName is entered.

func (*BaseRelationalParserListener) EnterExpressions

func (s *BaseRelationalParserListener) EnterExpressions(ctx *ExpressionsContext)

EnterExpressions is called when production expressions is entered.

func (*BaseRelationalParserListener) EnterExpressionsWithDefaults

func (s *BaseRelationalParserListener) EnterExpressionsWithDefaults(ctx *ExpressionsWithDefaultsContext)

EnterExpressionsWithDefaults is called when production expressionsWithDefaults is entered.

func (*BaseRelationalParserListener) EnterExtractFunctionCall

func (s *BaseRelationalParserListener) EnterExtractFunctionCall(ctx *ExtractFunctionCallContext)

EnterExtractFunctionCall is called when production extractFunctionCall is entered.

func (*BaseRelationalParserListener) EnterFromClause

func (s *BaseRelationalParserListener) EnterFromClause(ctx *FromClauseContext)

EnterFromClause is called when production fromClause is entered.

func (*BaseRelationalParserListener) EnterFullColumnName

func (s *BaseRelationalParserListener) EnterFullColumnName(ctx *FullColumnNameContext)

EnterFullColumnName is called when production fullColumnName is entered.

func (*BaseRelationalParserListener) EnterFullColumnNameExpressionAtom

func (s *BaseRelationalParserListener) EnterFullColumnNameExpressionAtom(ctx *FullColumnNameExpressionAtomContext)

EnterFullColumnNameExpressionAtom is called when production fullColumnNameExpressionAtom is entered.

func (*BaseRelationalParserListener) EnterFullDescribeStatement

func (s *BaseRelationalParserListener) EnterFullDescribeStatement(ctx *FullDescribeStatementContext)

EnterFullDescribeStatement is called when production fullDescribeStatement is entered.

func (*BaseRelationalParserListener) EnterFullId

func (s *BaseRelationalParserListener) EnterFullId(ctx *FullIdContext)

EnterFullId is called when production fullId is entered.

func (*BaseRelationalParserListener) EnterFullIdList

func (s *BaseRelationalParserListener) EnterFullIdList(ctx *FullIdListContext)

EnterFullIdList is called when production fullIdList is entered.

func (*BaseRelationalParserListener) EnterFunctionArg

func (s *BaseRelationalParserListener) EnterFunctionArg(ctx *FunctionArgContext)

EnterFunctionArg is called when production functionArg is entered.

func (*BaseRelationalParserListener) EnterFunctionArgs

func (s *BaseRelationalParserListener) EnterFunctionArgs(ctx *FunctionArgsContext)

EnterFunctionArgs is called when production functionArgs is entered.

func (*BaseRelationalParserListener) EnterFunctionCallExpressionAtom

func (s *BaseRelationalParserListener) EnterFunctionCallExpressionAtom(ctx *FunctionCallExpressionAtomContext)

EnterFunctionCallExpressionAtom is called when production functionCallExpressionAtom is entered.

func (*BaseRelationalParserListener) EnterFunctionColumnType

func (s *BaseRelationalParserListener) EnterFunctionColumnType(ctx *FunctionColumnTypeContext)

EnterFunctionColumnType is called when production functionColumnType is entered.

func (*BaseRelationalParserListener) EnterFunctionNameBase

func (s *BaseRelationalParserListener) EnterFunctionNameBase(ctx *FunctionNameBaseContext)

EnterFunctionNameBase is called when production functionNameBase is entered.

func (*BaseRelationalParserListener) EnterFunctionNameKeyword

func (s *BaseRelationalParserListener) EnterFunctionNameKeyword(ctx *FunctionNameKeywordContext)

EnterFunctionNameKeyword is called when production functionNameKeyword is entered.

func (*BaseRelationalParserListener) EnterFunctionSpecification

func (s *BaseRelationalParserListener) EnterFunctionSpecification(ctx *FunctionSpecificationContext)

EnterFunctionSpecification is called when production functionSpecification is entered.

func (*BaseRelationalParserListener) EnterGetFormatFunctionCall

func (s *BaseRelationalParserListener) EnterGetFormatFunctionCall(ctx *GetFormatFunctionCallContext)

EnterGetFormatFunctionCall is called when production getFormatFunctionCall is entered.

func (*BaseRelationalParserListener) EnterGroupByClause

func (s *BaseRelationalParserListener) EnterGroupByClause(ctx *GroupByClauseContext)

EnterGroupByClause is called when production groupByClause is entered.

func (*BaseRelationalParserListener) EnterGroupByItem

func (s *BaseRelationalParserListener) EnterGroupByItem(ctx *GroupByItemContext)

EnterGroupByItem is called when production groupByItem is entered.

func (*BaseRelationalParserListener) EnterHavingClause

func (s *BaseRelationalParserListener) EnterHavingClause(ctx *HavingClauseContext)

EnterHavingClause is called when production havingClause is entered.

func (*BaseRelationalParserListener) EnterHelpStatement

func (s *BaseRelationalParserListener) EnterHelpStatement(ctx *HelpStatementContext)

EnterHelpStatement is called when production helpStatement is entered.

func (*BaseRelationalParserListener) EnterHnswMetric

func (s *BaseRelationalParserListener) EnterHnswMetric(ctx *HnswMetricContext)

EnterHnswMetric is called when production hnswMetric is entered.

func (*BaseRelationalParserListener) EnterIfExists

func (s *BaseRelationalParserListener) EnterIfExists(ctx *IfExistsContext)

EnterIfExists is called when production ifExists is entered.

func (*BaseRelationalParserListener) EnterIfNotExists

func (s *BaseRelationalParserListener) EnterIfNotExists(ctx *IfNotExistsContext)

EnterIfNotExists is called when production ifNotExists is entered.

func (*BaseRelationalParserListener) EnterInList

func (s *BaseRelationalParserListener) EnterInList(ctx *InListContext)

EnterInList is called when production inList is entered.

func (*BaseRelationalParserListener) EnterInPredicate

func (s *BaseRelationalParserListener) EnterInPredicate(ctx *InPredicateContext)

EnterInPredicate is called when production inPredicate is entered.

func (*BaseRelationalParserListener) EnterIncludeClause

func (s *BaseRelationalParserListener) EnterIncludeClause(ctx *IncludeClauseContext)

EnterIncludeClause is called when production includeClause is entered.

func (*BaseRelationalParserListener) EnterIndexAsSelectDefinition

func (s *BaseRelationalParserListener) EnterIndexAsSelectDefinition(ctx *IndexAsSelectDefinitionContext)

EnterIndexAsSelectDefinition is called when production indexAsSelectDefinition is entered.

func (*BaseRelationalParserListener) EnterIndexAttribute

func (s *BaseRelationalParserListener) EnterIndexAttribute(ctx *IndexAttributeContext)

EnterIndexAttribute is called when production indexAttribute is entered.

func (*BaseRelationalParserListener) EnterIndexAttributes

func (s *BaseRelationalParserListener) EnterIndexAttributes(ctx *IndexAttributesContext)

EnterIndexAttributes is called when production indexAttributes is entered.

func (*BaseRelationalParserListener) EnterIndexColumnList

func (s *BaseRelationalParserListener) EnterIndexColumnList(ctx *IndexColumnListContext)

EnterIndexColumnList is called when production indexColumnList is entered.

func (*BaseRelationalParserListener) EnterIndexColumnName

func (s *BaseRelationalParserListener) EnterIndexColumnName(ctx *IndexColumnNameContext)

EnterIndexColumnName is called when production indexColumnName is entered.

func (*BaseRelationalParserListener) EnterIndexColumnNames

func (s *BaseRelationalParserListener) EnterIndexColumnNames(ctx *IndexColumnNamesContext)

EnterIndexColumnNames is called when production indexColumnNames is entered.

func (*BaseRelationalParserListener) EnterIndexColumnSpec

func (s *BaseRelationalParserListener) EnterIndexColumnSpec(ctx *IndexColumnSpecContext)

EnterIndexColumnSpec is called when production indexColumnSpec is entered.

func (*BaseRelationalParserListener) EnterIndexHint

func (s *BaseRelationalParserListener) EnterIndexHint(ctx *IndexHintContext)

EnterIndexHint is called when production indexHint is entered.

func (*BaseRelationalParserListener) EnterIndexHintType

func (s *BaseRelationalParserListener) EnterIndexHintType(ctx *IndexHintTypeContext)

EnterIndexHintType is called when production indexHintType is entered.

func (*BaseRelationalParserListener) EnterIndexOnSourceDefinition

func (s *BaseRelationalParserListener) EnterIndexOnSourceDefinition(ctx *IndexOnSourceDefinitionContext)

EnterIndexOnSourceDefinition is called when production indexOnSourceDefinition is entered.

func (*BaseRelationalParserListener) EnterIndexOption

func (s *BaseRelationalParserListener) EnterIndexOption(ctx *IndexOptionContext)

EnterIndexOption is called when production indexOption is entered.

func (*BaseRelationalParserListener) EnterIndexOptions

func (s *BaseRelationalParserListener) EnterIndexOptions(ctx *IndexOptionsContext)

EnterIndexOptions is called when production indexOptions is entered.

func (*BaseRelationalParserListener) EnterIndexPartitionClause

func (s *BaseRelationalParserListener) EnterIndexPartitionClause(ctx *IndexPartitionClauseContext)

EnterIndexPartitionClause is called when production indexPartitionClause is entered.

func (*BaseRelationalParserListener) EnterIndexType

func (s *BaseRelationalParserListener) EnterIndexType(ctx *IndexTypeContext)

EnterIndexType is called when production indexType is entered.

func (*BaseRelationalParserListener) EnterInlineTableDefinition

func (s *BaseRelationalParserListener) EnterInlineTableDefinition(ctx *InlineTableDefinitionContext)

EnterInlineTableDefinition is called when production inlineTableDefinition is entered.

func (*BaseRelationalParserListener) EnterInlineTableItem

func (s *BaseRelationalParserListener) EnterInlineTableItem(ctx *InlineTableItemContext)

EnterInlineTableItem is called when production inlineTableItem is entered.

func (*BaseRelationalParserListener) EnterInnerJoin

func (s *BaseRelationalParserListener) EnterInnerJoin(ctx *InnerJoinContext)

EnterInnerJoin is called when production innerJoin is entered.

func (*BaseRelationalParserListener) EnterInsertStatement

func (s *BaseRelationalParserListener) EnterInsertStatement(ctx *InsertStatementContext)

EnterInsertStatement is called when production insertStatement is entered.

func (*BaseRelationalParserListener) EnterInsertStatementValueSelect

func (s *BaseRelationalParserListener) EnterInsertStatementValueSelect(ctx *InsertStatementValueSelectContext)

EnterInsertStatementValueSelect is called when production insertStatementValueSelect is entered.

func (*BaseRelationalParserListener) EnterInsertStatementValueValues

func (s *BaseRelationalParserListener) EnterInsertStatementValueValues(ctx *InsertStatementValueValuesContext)

EnterInsertStatementValueValues is called when production insertStatementValueValues is entered.

func (*BaseRelationalParserListener) EnterIntervalType

func (s *BaseRelationalParserListener) EnterIntervalType(ctx *IntervalTypeContext)

EnterIntervalType is called when production intervalType is entered.

func (*BaseRelationalParserListener) EnterIntervalTypeBase

func (s *BaseRelationalParserListener) EnterIntervalTypeBase(ctx *IntervalTypeBaseContext)

EnterIntervalTypeBase is called when production intervalTypeBase is entered.

func (*BaseRelationalParserListener) EnterIsExpression

func (s *BaseRelationalParserListener) EnterIsExpression(ctx *IsExpressionContext)

EnterIsExpression is called when production isExpression is entered.

func (*BaseRelationalParserListener) EnterJsonOperator

func (s *BaseRelationalParserListener) EnterJsonOperator(ctx *JsonOperatorContext)

EnterJsonOperator is called when production jsonOperator is entered.

func (*BaseRelationalParserListener) EnterKeywordsCanBeId

func (s *BaseRelationalParserListener) EnterKeywordsCanBeId(ctx *KeywordsCanBeIdContext)

EnterKeywordsCanBeId is called when production keywordsCanBeId is entered.

func (*BaseRelationalParserListener) EnterKillStatement

func (s *BaseRelationalParserListener) EnterKillStatement(ctx *KillStatementContext)

EnterKillStatement is called when production killStatement is entered.

func (*BaseRelationalParserListener) EnterLanguageClause

func (s *BaseRelationalParserListener) EnterLanguageClause(ctx *LanguageClauseContext)

EnterLanguageClause is called when production languageClause is entered.

func (*BaseRelationalParserListener) EnterLanguageName

func (s *BaseRelationalParserListener) EnterLanguageName(ctx *LanguageNameContext)

EnterLanguageName is called when production languageName is entered.

func (*BaseRelationalParserListener) EnterLengthOneDimension

func (s *BaseRelationalParserListener) EnterLengthOneDimension(ctx *LengthOneDimensionContext)

EnterLengthOneDimension is called when production lengthOneDimension is entered.

func (*BaseRelationalParserListener) EnterLengthTwoDimension

func (s *BaseRelationalParserListener) EnterLengthTwoDimension(ctx *LengthTwoDimensionContext)

EnterLengthTwoDimension is called when production lengthTwoDimension is entered.

func (*BaseRelationalParserListener) EnterLengthTwoOptionalDimension

func (s *BaseRelationalParserListener) EnterLengthTwoOptionalDimension(ctx *LengthTwoOptionalDimensionContext)

EnterLengthTwoOptionalDimension is called when production lengthTwoOptionalDimension is entered.

func (*BaseRelationalParserListener) EnterLevelInWeightListElement

func (s *BaseRelationalParserListener) EnterLevelInWeightListElement(ctx *LevelInWeightListElementContext)

EnterLevelInWeightListElement is called when production levelInWeightListElement is entered.

func (*BaseRelationalParserListener) EnterLevelWeightList

func (s *BaseRelationalParserListener) EnterLevelWeightList(ctx *LevelWeightListContext)

EnterLevelWeightList is called when production levelWeightList is entered.

func (*BaseRelationalParserListener) EnterLevelWeightRange

func (s *BaseRelationalParserListener) EnterLevelWeightRange(ctx *LevelWeightRangeContext)

EnterLevelWeightRange is called when production levelWeightRange is entered.

func (*BaseRelationalParserListener) EnterLikePredicate

func (s *BaseRelationalParserListener) EnterLikePredicate(ctx *LikePredicateContext)

EnterLikePredicate is called when production likePredicate is entered.

func (*BaseRelationalParserListener) EnterLimitClause

func (s *BaseRelationalParserListener) EnterLimitClause(ctx *LimitClauseContext)

EnterLimitClause is called when production limitClause is entered.

func (*BaseRelationalParserListener) EnterLimitClauseAtom

func (s *BaseRelationalParserListener) EnterLimitClauseAtom(ctx *LimitClauseAtomContext)

EnterLimitClauseAtom is called when production limitClauseAtom is entered.

func (*BaseRelationalParserListener) EnterLoadedTableIndexes

func (s *BaseRelationalParserListener) EnterLoadedTableIndexes(ctx *LoadedTableIndexesContext)

EnterLoadedTableIndexes is called when production loadedTableIndexes is entered.

func (*BaseRelationalParserListener) EnterLogicalExpression

func (s *BaseRelationalParserListener) EnterLogicalExpression(ctx *LogicalExpressionContext)

EnterLogicalExpression is called when production logicalExpression is entered.

func (*BaseRelationalParserListener) EnterLogicalOperator

func (s *BaseRelationalParserListener) EnterLogicalOperator(ctx *LogicalOperatorContext)

EnterLogicalOperator is called when production logicalOperator is entered.

func (*BaseRelationalParserListener) EnterLongVarbinaryDataType

func (s *BaseRelationalParserListener) EnterLongVarbinaryDataType(ctx *LongVarbinaryDataTypeContext)

EnterLongVarbinaryDataType is called when production longVarbinaryDataType is entered.

func (*BaseRelationalParserListener) EnterLongVarcharDataType

func (s *BaseRelationalParserListener) EnterLongVarcharDataType(ctx *LongVarcharDataTypeContext)

EnterLongVarcharDataType is called when production longVarcharDataType is entered.

func (*BaseRelationalParserListener) EnterMathExpressionAtom

func (s *BaseRelationalParserListener) EnterMathExpressionAtom(ctx *MathExpressionAtomContext)

EnterMathExpressionAtom is called when production mathExpressionAtom is entered.

func (*BaseRelationalParserListener) EnterMathOperator

func (s *BaseRelationalParserListener) EnterMathOperator(ctx *MathOperatorContext)

EnterMathOperator is called when production mathOperator is entered.

func (*BaseRelationalParserListener) EnterNamedFunctionArg

func (s *BaseRelationalParserListener) EnterNamedFunctionArg(ctx *NamedFunctionArgContext)

EnterNamedFunctionArg is called when production namedFunctionArg is entered.

func (*BaseRelationalParserListener) EnterNamedOrUnnamedFunctionArgs

func (s *BaseRelationalParserListener) EnterNamedOrUnnamedFunctionArgs(ctx *NamedOrUnnamedFunctionArgsContext)

EnterNamedOrUnnamedFunctionArgs is called when production namedOrUnnamedFunctionArgs is entered.

func (*BaseRelationalParserListener) EnterNamedQuery

func (s *BaseRelationalParserListener) EnterNamedQuery(ctx *NamedQueryContext)

EnterNamedQuery is called when production namedQuery is entered.

func (*BaseRelationalParserListener) EnterNationalStringDataType

func (s *BaseRelationalParserListener) EnterNationalStringDataType(ctx *NationalStringDataTypeContext)

EnterNationalStringDataType is called when production nationalStringDataType is entered.

func (*BaseRelationalParserListener) EnterNationalVaryingStringDataType

func (s *BaseRelationalParserListener) EnterNationalVaryingStringDataType(ctx *NationalVaryingStringDataTypeContext)

EnterNationalVaryingStringDataType is called when production nationalVaryingStringDataType is entered.

func (*BaseRelationalParserListener) EnterNaturalJoin

func (s *BaseRelationalParserListener) EnterNaturalJoin(ctx *NaturalJoinContext)

EnterNaturalJoin is called when production naturalJoin is entered.

func (*BaseRelationalParserListener) EnterNegativeDecimalConstant

func (s *BaseRelationalParserListener) EnterNegativeDecimalConstant(ctx *NegativeDecimalConstantContext)

EnterNegativeDecimalConstant is called when production negativeDecimalConstant is entered.

func (*BaseRelationalParserListener) EnterNonAggregateFunctionCall

func (s *BaseRelationalParserListener) EnterNonAggregateFunctionCall(ctx *NonAggregateFunctionCallContext)

EnterNonAggregateFunctionCall is called when production nonAggregateFunctionCall is entered.

func (*BaseRelationalParserListener) EnterNonAggregateWindowedFunction

func (s *BaseRelationalParserListener) EnterNonAggregateWindowedFunction(ctx *NonAggregateWindowedFunctionContext)

EnterNonAggregateWindowedFunction is called when production nonAggregateWindowedFunction is entered.

func (*BaseRelationalParserListener) EnterNotExpression

func (s *BaseRelationalParserListener) EnterNotExpression(ctx *NotExpressionContext)

EnterNotExpression is called when production notExpression is entered.

func (*BaseRelationalParserListener) EnterNullCallClause

func (s *BaseRelationalParserListener) EnterNullCallClause(ctx *NullCallClauseContext)

EnterNullCallClause is called when production nullCallClause is entered.

func (*BaseRelationalParserListener) EnterNullColumnConstraint

func (s *BaseRelationalParserListener) EnterNullColumnConstraint(ctx *NullColumnConstraintContext)

EnterNullColumnConstraint is called when production nullColumnConstraint is entered.

func (*BaseRelationalParserListener) EnterNullConstant

func (s *BaseRelationalParserListener) EnterNullConstant(ctx *NullConstantContext)

EnterNullConstant is called when production nullConstant is entered.

func (*BaseRelationalParserListener) EnterNullLiteral

func (s *BaseRelationalParserListener) EnterNullLiteral(ctx *NullLiteralContext)

EnterNullLiteral is called when production nullLiteral is entered.

func (*BaseRelationalParserListener) EnterNullNotnull

func (s *BaseRelationalParserListener) EnterNullNotnull(ctx *NullNotnullContext)

EnterNullNotnull is called when production nullNotnull is entered.

func (*BaseRelationalParserListener) EnterNullTreatmentClause

func (s *BaseRelationalParserListener) EnterNullTreatmentClause(ctx *NullTreatmentClauseContext)

EnterNullTreatmentClause is called when production nullTreatmentClause is entered.

func (*BaseRelationalParserListener) EnterOfTypeClause

func (s *BaseRelationalParserListener) EnterOfTypeClause(ctx *OfTypeClauseContext)

EnterOfTypeClause is called when production ofTypeClause is entered.

func (*BaseRelationalParserListener) EnterOption

func (s *BaseRelationalParserListener) EnterOption(ctx *OptionContext)

EnterOption is called when production option is entered.

func (*BaseRelationalParserListener) EnterOptionsClause

func (s *BaseRelationalParserListener) EnterOptionsClause(ctx *OptionsClauseContext)

EnterOptionsClause is called when production optionsClause is entered.

func (*BaseRelationalParserListener) EnterOrderByClause

func (s *BaseRelationalParserListener) EnterOrderByClause(ctx *OrderByClauseContext)

EnterOrderByClause is called when production orderByClause is entered.

func (*BaseRelationalParserListener) EnterOrderByExpression

func (s *BaseRelationalParserListener) EnterOrderByExpression(ctx *OrderByExpressionContext)

EnterOrderByExpression is called when production orderByExpression is entered.

func (*BaseRelationalParserListener) EnterOrderClause

func (s *BaseRelationalParserListener) EnterOrderClause(ctx *OrderClauseContext)

EnterOrderClause is called when production orderClause is entered.

func (*BaseRelationalParserListener) EnterOuterJoin

func (s *BaseRelationalParserListener) EnterOuterJoin(ctx *OuterJoinContext)

EnterOuterJoin is called when production outerJoin is entered.

func (*BaseRelationalParserListener) EnterOverClause

func (s *BaseRelationalParserListener) EnterOverClause(ctx *OverClauseContext)

EnterOverClause is called when production overClause is entered.

func (*BaseRelationalParserListener) EnterParameterMode

func (s *BaseRelationalParserListener) EnterParameterMode(ctx *ParameterModeContext)

EnterParameterMode is called when production parameterMode is entered.

func (*BaseRelationalParserListener) EnterParameterStyle

func (s *BaseRelationalParserListener) EnterParameterStyle(ctx *ParameterStyleContext)

EnterParameterStyle is called when production parameterStyle is entered.

func (*BaseRelationalParserListener) EnterParenthesisQuery

func (s *BaseRelationalParserListener) EnterParenthesisQuery(ctx *ParenthesisQueryContext)

EnterParenthesisQuery is called when production parenthesisQuery is entered.

func (*BaseRelationalParserListener) EnterPartitionClause

func (s *BaseRelationalParserListener) EnterPartitionClause(ctx *PartitionClauseContext)

EnterPartitionClause is called when production partitionClause is entered.

func (*BaseRelationalParserListener) EnterPath

func (s *BaseRelationalParserListener) EnterPath(ctx *PathContext)

EnterPath is called when production path is entered.

func (*BaseRelationalParserListener) EnterPositionFunctionCall

func (s *BaseRelationalParserListener) EnterPositionFunctionCall(ctx *PositionFunctionCallContext)

EnterPositionFunctionCall is called when production positionFunctionCall is entered.

func (*BaseRelationalParserListener) EnterPredicatedExpression

func (s *BaseRelationalParserListener) EnterPredicatedExpression(ctx *PredicatedExpressionContext)

EnterPredicatedExpression is called when production predicatedExpression is entered.

func (*BaseRelationalParserListener) EnterPrepareStatement

func (s *BaseRelationalParserListener) EnterPrepareStatement(ctx *PrepareStatementContext)

EnterPrepareStatement is called when production prepareStatement is entered.

func (*BaseRelationalParserListener) EnterPreparedStatement

func (s *BaseRelationalParserListener) EnterPreparedStatement(ctx *PreparedStatementContext)

EnterPreparedStatement is called when production preparedStatement is entered.

func (*BaseRelationalParserListener) EnterPreparedStatementParameter

func (s *BaseRelationalParserListener) EnterPreparedStatementParameter(ctx *PreparedStatementParameterContext)

EnterPreparedStatementParameter is called when production preparedStatementParameter is entered.

func (*BaseRelationalParserListener) EnterPreparedStatementParameterAtom

func (s *BaseRelationalParserListener) EnterPreparedStatementParameterAtom(ctx *PreparedStatementParameterAtomContext)

EnterPreparedStatementParameterAtom is called when production preparedStatementParameterAtom is entered.

func (*BaseRelationalParserListener) EnterPrimaryKeyDefinition

func (s *BaseRelationalParserListener) EnterPrimaryKeyDefinition(ctx *PrimaryKeyDefinitionContext)

EnterPrimaryKeyDefinition is called when production primaryKeyDefinition is entered.

func (*BaseRelationalParserListener) EnterPrimitiveType

func (s *BaseRelationalParserListener) EnterPrimitiveType(ctx *PrimitiveTypeContext)

EnterPrimitiveType is called when production primitiveType is entered.

func (*BaseRelationalParserListener) EnterQualifyClause

func (s *BaseRelationalParserListener) EnterQualifyClause(ctx *QualifyClauseContext)

EnterQualifyClause is called when production qualifyClause is entered.

func (*BaseRelationalParserListener) EnterQuery

func (s *BaseRelationalParserListener) EnterQuery(ctx *QueryContext)

EnterQuery is called when production query is entered.

func (*BaseRelationalParserListener) EnterQueryTermDefault

func (s *BaseRelationalParserListener) EnterQueryTermDefault(ctx *QueryTermDefaultContext)

EnterQueryTermDefault is called when production queryTermDefault is entered.

func (*BaseRelationalParserListener) EnterRecordConstructor

func (s *BaseRelationalParserListener) EnterRecordConstructor(ctx *RecordConstructorContext)

EnterRecordConstructor is called when production recordConstructor is entered.

func (*BaseRelationalParserListener) EnterRecordConstructorExpressionAtom

func (s *BaseRelationalParserListener) EnterRecordConstructorExpressionAtom(ctx *RecordConstructorExpressionAtomContext)

EnterRecordConstructorExpressionAtom is called when production recordConstructorExpressionAtom is entered.

func (*BaseRelationalParserListener) EnterRecordConstructorForInlineTable

func (s *BaseRelationalParserListener) EnterRecordConstructorForInlineTable(ctx *RecordConstructorForInlineTableContext)

EnterRecordConstructorForInlineTable is called when production recordConstructorForInlineTable is entered.

func (*BaseRelationalParserListener) EnterRecordConstructorForInsert

func (s *BaseRelationalParserListener) EnterRecordConstructorForInsert(ctx *RecordConstructorForInsertContext)

EnterRecordConstructorForInsert is called when production recordConstructorForInsert is entered.

func (*BaseRelationalParserListener) EnterResetStatement

func (s *BaseRelationalParserListener) EnterResetStatement(ctx *ResetStatementContext)

EnterResetStatement is called when production resetStatement is entered.

func (*BaseRelationalParserListener) EnterReturnsClause

func (s *BaseRelationalParserListener) EnterReturnsClause(ctx *ReturnsClauseContext)

EnterReturnsClause is called when production returnsClause is entered.

func (*BaseRelationalParserListener) EnterReturnsTableType

func (s *BaseRelationalParserListener) EnterReturnsTableType(ctx *ReturnsTableTypeContext)

EnterReturnsTableType is called when production returnsTableType is entered.

func (*BaseRelationalParserListener) EnterReturnsType

func (s *BaseRelationalParserListener) EnterReturnsType(ctx *ReturnsTypeContext)

EnterReturnsType is called when production returnsType is entered.

func (*BaseRelationalParserListener) EnterRollbackStatement

func (s *BaseRelationalParserListener) EnterRollbackStatement(ctx *RollbackStatementContext)

EnterRollbackStatement is called when production rollbackStatement is entered.

func (*BaseRelationalParserListener) EnterRoot

func (s *BaseRelationalParserListener) EnterRoot(ctx *RootContext)

EnterRoot is called when production root is entered.

func (*BaseRelationalParserListener) EnterRoutineCharacteristics

func (s *BaseRelationalParserListener) EnterRoutineCharacteristics(ctx *RoutineCharacteristicsContext)

EnterRoutineCharacteristics is called when production routineCharacteristics is entered.

func (*BaseRelationalParserListener) EnterScalarFunctionCall

func (s *BaseRelationalParserListener) EnterScalarFunctionCall(ctx *ScalarFunctionCallContext)

EnterScalarFunctionCall is called when production scalarFunctionCall is entered.

func (*BaseRelationalParserListener) EnterScalarFunctionName

func (s *BaseRelationalParserListener) EnterScalarFunctionName(ctx *ScalarFunctionNameContext)

EnterScalarFunctionName is called when production scalarFunctionName is entered.

func (*BaseRelationalParserListener) EnterSchemaId

func (s *BaseRelationalParserListener) EnterSchemaId(ctx *SchemaIdContext)

EnterSchemaId is called when production schemaId is entered.

func (*BaseRelationalParserListener) EnterSchemaTemplateId

func (s *BaseRelationalParserListener) EnterSchemaTemplateId(ctx *SchemaTemplateIdContext)

EnterSchemaTemplateId is called when production schemaTemplateId is entered.

func (*BaseRelationalParserListener) EnterSelectElements

func (s *BaseRelationalParserListener) EnterSelectElements(ctx *SelectElementsContext)

EnterSelectElements is called when production selectElements is entered.

func (*BaseRelationalParserListener) EnterSelectExpressionElement

func (s *BaseRelationalParserListener) EnterSelectExpressionElement(ctx *SelectExpressionElementContext)

EnterSelectExpressionElement is called when production selectExpressionElement is entered.

func (*BaseRelationalParserListener) EnterSelectQualifierStarElement

func (s *BaseRelationalParserListener) EnterSelectQualifierStarElement(ctx *SelectQualifierStarElementContext)

EnterSelectQualifierStarElement is called when production selectQualifierStarElement is entered.

func (*BaseRelationalParserListener) EnterSelectStarElement

func (s *BaseRelationalParserListener) EnterSelectStarElement(ctx *SelectStarElementContext)

EnterSelectStarElement is called when production selectStarElement is entered.

func (*BaseRelationalParserListener) EnterSelectStatement

func (s *BaseRelationalParserListener) EnterSelectStatement(ctx *SelectStatementContext)

EnterSelectStatement is called when production selectStatement is entered.

func (*BaseRelationalParserListener) EnterSetAutocommit

func (s *BaseRelationalParserListener) EnterSetAutocommit(ctx *SetAutocommitContext)

EnterSetAutocommit is called when production setAutocommit is entered.

func (*BaseRelationalParserListener) EnterSetAutocommitStatement

func (s *BaseRelationalParserListener) EnterSetAutocommitStatement(ctx *SetAutocommitStatementContext)

EnterSetAutocommitStatement is called when production setAutocommitStatement is entered.

func (*BaseRelationalParserListener) EnterSetCharset

func (s *BaseRelationalParserListener) EnterSetCharset(ctx *SetCharsetContext)

EnterSetCharset is called when production setCharset is entered.

func (*BaseRelationalParserListener) EnterSetNames

func (s *BaseRelationalParserListener) EnterSetNames(ctx *SetNamesContext)

EnterSetNames is called when production setNames is entered.

func (*BaseRelationalParserListener) EnterSetNewValueInsideTrigger

func (s *BaseRelationalParserListener) EnterSetNewValueInsideTrigger(ctx *SetNewValueInsideTriggerContext)

EnterSetNewValueInsideTrigger is called when production setNewValueInsideTrigger is entered.

func (*BaseRelationalParserListener) EnterSetQuery

func (s *BaseRelationalParserListener) EnterSetQuery(ctx *SetQueryContext)

EnterSetQuery is called when production setQuery is entered.

func (*BaseRelationalParserListener) EnterSetTransaction

func (s *BaseRelationalParserListener) EnterSetTransaction(ctx *SetTransactionContext)

EnterSetTransaction is called when production setTransaction is entered.

func (*BaseRelationalParserListener) EnterSetTransactionStatement

func (s *BaseRelationalParserListener) EnterSetTransactionStatement(ctx *SetTransactionStatementContext)

EnterSetTransactionStatement is called when production setTransactionStatement is entered.

func (*BaseRelationalParserListener) EnterSetVariable

func (s *BaseRelationalParserListener) EnterSetVariable(ctx *SetVariableContext)

EnterSetVariable is called when production setVariable is entered.

func (*BaseRelationalParserListener) EnterShowDatabasesStatement

func (s *BaseRelationalParserListener) EnterShowDatabasesStatement(ctx *ShowDatabasesStatementContext)

EnterShowDatabasesStatement is called when production showDatabasesStatement is entered.

func (*BaseRelationalParserListener) EnterShowSchemaTemplatesStatement

func (s *BaseRelationalParserListener) EnterShowSchemaTemplatesStatement(ctx *ShowSchemaTemplatesStatementContext)

EnterShowSchemaTemplatesStatement is called when production showSchemaTemplatesStatement is entered.

func (*BaseRelationalParserListener) EnterSimpleDataType

func (s *BaseRelationalParserListener) EnterSimpleDataType(ctx *SimpleDataTypeContext)

EnterSimpleDataType is called when production simpleDataType is entered.

func (*BaseRelationalParserListener) EnterSimpleDescribeSchemaStatement

func (s *BaseRelationalParserListener) EnterSimpleDescribeSchemaStatement(ctx *SimpleDescribeSchemaStatementContext)

EnterSimpleDescribeSchemaStatement is called when production simpleDescribeSchemaStatement is entered.

func (*BaseRelationalParserListener) EnterSimpleDescribeSchemaTemplateStatement

func (s *BaseRelationalParserListener) EnterSimpleDescribeSchemaTemplateStatement(ctx *SimpleDescribeSchemaTemplateStatementContext)

EnterSimpleDescribeSchemaTemplateStatement is called when production simpleDescribeSchemaTemplateStatement is entered.

func (*BaseRelationalParserListener) EnterSimpleFunctionCall

func (s *BaseRelationalParserListener) EnterSimpleFunctionCall(ctx *SimpleFunctionCallContext)

EnterSimpleFunctionCall is called when production simpleFunctionCall is entered.

func (*BaseRelationalParserListener) EnterSimpleId

func (s *BaseRelationalParserListener) EnterSimpleId(ctx *SimpleIdContext)

EnterSimpleId is called when production simpleId is entered.

func (*BaseRelationalParserListener) EnterSimpleTable

func (s *BaseRelationalParserListener) EnterSimpleTable(ctx *SimpleTableContext)

EnterSimpleTable is called when production simpleTable is entered.

func (*BaseRelationalParserListener) EnterSpatialDataType

func (s *BaseRelationalParserListener) EnterSpatialDataType(ctx *SpatialDataTypeContext)

EnterSpatialDataType is called when production spatialDataType is entered.

func (*BaseRelationalParserListener) EnterSpecificFunctionCall

func (s *BaseRelationalParserListener) EnterSpecificFunctionCall(ctx *SpecificFunctionCallContext)

EnterSpecificFunctionCall is called when production specificFunctionCall is entered.

func (*BaseRelationalParserListener) EnterSqlInvokedFunction

func (s *BaseRelationalParserListener) EnterSqlInvokedFunction(ctx *SqlInvokedFunctionContext)

EnterSqlInvokedFunction is called when production sqlInvokedFunction is entered.

func (*BaseRelationalParserListener) EnterSqlParameterDeclaration

func (s *BaseRelationalParserListener) EnterSqlParameterDeclaration(ctx *SqlParameterDeclarationContext)

EnterSqlParameterDeclaration is called when production sqlParameterDeclaration is entered.

func (*BaseRelationalParserListener) EnterSqlParameterDeclarationList

func (s *BaseRelationalParserListener) EnterSqlParameterDeclarationList(ctx *SqlParameterDeclarationListContext)

EnterSqlParameterDeclarationList is called when production sqlParameterDeclarationList is entered.

func (*BaseRelationalParserListener) EnterSqlParameterDeclarations

func (s *BaseRelationalParserListener) EnterSqlParameterDeclarations(ctx *SqlParameterDeclarationsContext)

EnterSqlParameterDeclarations is called when production sqlParameterDeclarations is entered.

func (*BaseRelationalParserListener) EnterStartTransaction

func (s *BaseRelationalParserListener) EnterStartTransaction(ctx *StartTransactionContext)

EnterStartTransaction is called when production startTransaction is entered.

func (*BaseRelationalParserListener) EnterStatement

func (s *BaseRelationalParserListener) EnterStatement(ctx *StatementContext)

EnterStatement is called when production statement is entered.

func (*BaseRelationalParserListener) EnterStatementBody

func (s *BaseRelationalParserListener) EnterStatementBody(ctx *StatementBodyContext)

EnterStatementBody is called when production statementBody is entered.

func (*BaseRelationalParserListener) EnterStatementOption

func (s *BaseRelationalParserListener) EnterStatementOption(ctx *StatementOptionContext)

EnterStatementOption is called when production statementOption is entered.

func (*BaseRelationalParserListener) EnterStatementOptions

func (s *BaseRelationalParserListener) EnterStatementOptions(ctx *StatementOptionsContext)

EnterStatementOptions is called when production statementOptions is entered.

func (*BaseRelationalParserListener) EnterStatements

func (s *BaseRelationalParserListener) EnterStatements(ctx *StatementsContext)

EnterStatements is called when production statements is entered.

func (*BaseRelationalParserListener) EnterStoredQueryDefinition

func (s *BaseRelationalParserListener) EnterStoredQueryDefinition(ctx *StoredQueryDefinitionContext)

EnterStoredQueryDefinition is called when production storedQueryDefinition is entered.

func (*BaseRelationalParserListener) EnterStraightJoin

func (s *BaseRelationalParserListener) EnterStraightJoin(ctx *StraightJoinContext)

EnterStraightJoin is called when production straightJoin is entered.

func (*BaseRelationalParserListener) EnterStringConstant

func (s *BaseRelationalParserListener) EnterStringConstant(ctx *StringConstantContext)

EnterStringConstant is called when production stringConstant is entered.

func (*BaseRelationalParserListener) EnterStringDataType

func (s *BaseRelationalParserListener) EnterStringDataType(ctx *StringDataTypeContext)

EnterStringDataType is called when production stringDataType is entered.

func (*BaseRelationalParserListener) EnterStringLiteral

func (s *BaseRelationalParserListener) EnterStringLiteral(ctx *StringLiteralContext)

EnterStringLiteral is called when production stringLiteral is entered.

func (*BaseRelationalParserListener) EnterStructDefinition

func (s *BaseRelationalParserListener) EnterStructDefinition(ctx *StructDefinitionContext)

EnterStructDefinition is called when production structDefinition is entered.

func (*BaseRelationalParserListener) EnterSubqueryExpressionAtom

func (s *BaseRelationalParserListener) EnterSubqueryExpressionAtom(ctx *SubqueryExpressionAtomContext)

EnterSubqueryExpressionAtom is called when production subqueryExpressionAtom is entered.

func (*BaseRelationalParserListener) EnterSubqueryTableItem

func (s *BaseRelationalParserListener) EnterSubqueryTableItem(ctx *SubqueryTableItemContext)

EnterSubqueryTableItem is called when production subqueryTableItem is entered.

func (*BaseRelationalParserListener) EnterSubscriptExpression

func (s *BaseRelationalParserListener) EnterSubscriptExpression(ctx *SubscriptExpressionContext)

EnterSubscriptExpression is called when production subscriptExpression is entered.

func (*BaseRelationalParserListener) EnterSubstrFunctionCall

func (s *BaseRelationalParserListener) EnterSubstrFunctionCall(ctx *SubstrFunctionCallContext)

EnterSubstrFunctionCall is called when production substrFunctionCall is entered.

func (*BaseRelationalParserListener) EnterTableDefinition

func (s *BaseRelationalParserListener) EnterTableDefinition(ctx *TableDefinitionContext)

EnterTableDefinition is called when production tableDefinition is entered.

func (*BaseRelationalParserListener) EnterTableFunction

func (s *BaseRelationalParserListener) EnterTableFunction(ctx *TableFunctionContext)

EnterTableFunction is called when production tableFunction is entered.

func (*BaseRelationalParserListener) EnterTableFunctionColumnList

func (s *BaseRelationalParserListener) EnterTableFunctionColumnList(ctx *TableFunctionColumnListContext)

EnterTableFunctionColumnList is called when production tableFunctionColumnList is entered.

func (*BaseRelationalParserListener) EnterTableFunctionColumnListElement

func (s *BaseRelationalParserListener) EnterTableFunctionColumnListElement(ctx *TableFunctionColumnListElementContext)

EnterTableFunctionColumnListElement is called when production tableFunctionColumnListElement is entered.

func (*BaseRelationalParserListener) EnterTableFunctionName

func (s *BaseRelationalParserListener) EnterTableFunctionName(ctx *TableFunctionNameContext)

EnterTableFunctionName is called when production tableFunctionName is entered.

func (*BaseRelationalParserListener) EnterTableIndexes

func (s *BaseRelationalParserListener) EnterTableIndexes(ctx *TableIndexesContext)

EnterTableIndexes is called when production tableIndexes is entered.

func (*BaseRelationalParserListener) EnterTableName

func (s *BaseRelationalParserListener) EnterTableName(ctx *TableNameContext)

EnterTableName is called when production tableName is entered.

func (*BaseRelationalParserListener) EnterTableSourceBase

func (s *BaseRelationalParserListener) EnterTableSourceBase(ctx *TableSourceBaseContext)

EnterTableSourceBase is called when production tableSourceBase is entered.

func (*BaseRelationalParserListener) EnterTableSources

func (s *BaseRelationalParserListener) EnterTableSources(ctx *TableSourcesContext)

EnterTableSources is called when production tableSources is entered.

func (*BaseRelationalParserListener) EnterTableValuedFunction

func (s *BaseRelationalParserListener) EnterTableValuedFunction(ctx *TableValuedFunctionContext)

EnterTableValuedFunction is called when production tableValuedFunction is entered.

func (*BaseRelationalParserListener) EnterTables

func (s *BaseRelationalParserListener) EnterTables(ctx *TablesContext)

EnterTables is called when production tables is entered.

func (*BaseRelationalParserListener) EnterTempSqlInvokedFunction

func (s *BaseRelationalParserListener) EnterTempSqlInvokedFunction(ctx *TempSqlInvokedFunctionContext)

EnterTempSqlInvokedFunction is called when production tempSqlInvokedFunction is entered.

func (*BaseRelationalParserListener) EnterTemplateClause

func (s *BaseRelationalParserListener) EnterTemplateClause(ctx *TemplateClauseContext)

EnterTemplateClause is called when production templateClause is entered.

func (*BaseRelationalParserListener) EnterTransactionLevel

func (s *BaseRelationalParserListener) EnterTransactionLevel(ctx *TransactionLevelContext)

EnterTransactionLevel is called when production transactionLevel is entered.

func (*BaseRelationalParserListener) EnterTransactionOption

func (s *BaseRelationalParserListener) EnterTransactionOption(ctx *TransactionOptionContext)

EnterTransactionOption is called when production transactionOption is entered.

func (*BaseRelationalParserListener) EnterTransactionStatement

func (s *BaseRelationalParserListener) EnterTransactionStatement(ctx *TransactionStatementContext)

EnterTransactionStatement is called when production transactionStatement is entered.

func (*BaseRelationalParserListener) EnterTraversalOrderClause

func (s *BaseRelationalParserListener) EnterTraversalOrderClause(ctx *TraversalOrderClauseContext)

EnterTraversalOrderClause is called when production traversalOrderClause is entered.

func (*BaseRelationalParserListener) EnterTrimFunctionCall

func (s *BaseRelationalParserListener) EnterTrimFunctionCall(ctx *TrimFunctionCallContext)

EnterTrimFunctionCall is called when production trimFunctionCall is entered.

func (*BaseRelationalParserListener) EnterUid

func (s *BaseRelationalParserListener) EnterUid(ctx *UidContext)

EnterUid is called when production uid is entered.

func (*BaseRelationalParserListener) EnterUidList

func (s *BaseRelationalParserListener) EnterUidList(ctx *UidListContext)

EnterUidList is called when production uidList is entered.

func (*BaseRelationalParserListener) EnterUidListWithNestings

func (s *BaseRelationalParserListener) EnterUidListWithNestings(ctx *UidListWithNestingsContext)

EnterUidListWithNestings is called when production uidListWithNestings is entered.

func (*BaseRelationalParserListener) EnterUidListWithNestingsInParens

func (s *BaseRelationalParserListener) EnterUidListWithNestingsInParens(ctx *UidListWithNestingsInParensContext)

EnterUidListWithNestingsInParens is called when production uidListWithNestingsInParens is entered.

func (*BaseRelationalParserListener) EnterUidWithNestings

func (s *BaseRelationalParserListener) EnterUidWithNestings(ctx *UidWithNestingsContext)

EnterUidWithNestings is called when production uidWithNestings is entered.

func (*BaseRelationalParserListener) EnterUnaryOperator

func (s *BaseRelationalParserListener) EnterUnaryOperator(ctx *UnaryOperatorContext)

EnterUnaryOperator is called when production unaryOperator is entered.

func (*BaseRelationalParserListener) EnterUpdateStatement

func (s *BaseRelationalParserListener) EnterUpdateStatement(ctx *UpdateStatementContext)

EnterUpdateStatement is called when production updateStatement is entered.

func (*BaseRelationalParserListener) EnterUpdatedElement

func (s *BaseRelationalParserListener) EnterUpdatedElement(ctx *UpdatedElementContext)

EnterUpdatedElement is called when production updatedElement is entered.

func (*BaseRelationalParserListener) EnterUserDefinedMacroFunctionStatementBody

func (s *BaseRelationalParserListener) EnterUserDefinedMacroFunctionStatementBody(ctx *UserDefinedMacroFunctionStatementBodyContext)

EnterUserDefinedMacroFunctionStatementBody is called when production userDefinedMacroFunctionStatementBody is entered.

func (*BaseRelationalParserListener) EnterUserDefinedScalarFunctionCall

func (s *BaseRelationalParserListener) EnterUserDefinedScalarFunctionCall(ctx *UserDefinedScalarFunctionCallContext)

EnterUserDefinedScalarFunctionCall is called when production userDefinedScalarFunctionCall is entered.

func (*BaseRelationalParserListener) EnterUserDefinedScalarFunctionName

func (s *BaseRelationalParserListener) EnterUserDefinedScalarFunctionName(ctx *UserDefinedScalarFunctionNameContext)

EnterUserDefinedScalarFunctionName is called when production userDefinedScalarFunctionName is entered.

func (*BaseRelationalParserListener) EnterUserVariables

func (s *BaseRelationalParserListener) EnterUserVariables(ctx *UserVariablesContext)

EnterUserVariables is called when production userVariables is entered.

func (*BaseRelationalParserListener) EnterUtilityStatement

func (s *BaseRelationalParserListener) EnterUtilityStatement(ctx *UtilityStatementContext)

EnterUtilityStatement is called when production utilityStatement is entered.

func (*BaseRelationalParserListener) EnterValuesFunctionCall

func (s *BaseRelationalParserListener) EnterValuesFunctionCall(ctx *ValuesFunctionCallContext)

EnterValuesFunctionCall is called when production valuesFunctionCall is entered.

func (*BaseRelationalParserListener) EnterVariableClause

func (s *BaseRelationalParserListener) EnterVariableClause(ctx *VariableClauseContext)

EnterVariableClause is called when production variableClause is entered.

func (*BaseRelationalParserListener) EnterVectorElementType

func (s *BaseRelationalParserListener) EnterVectorElementType(ctx *VectorElementTypeContext)

EnterVectorElementType is called when production vectorElementType is entered.

func (*BaseRelationalParserListener) EnterVectorEngine

func (s *BaseRelationalParserListener) EnterVectorEngine(ctx *VectorEngineContext)

EnterVectorEngine is called when production vectorEngine is entered.

func (*BaseRelationalParserListener) EnterVectorIndexDefinition

func (s *BaseRelationalParserListener) EnterVectorIndexDefinition(ctx *VectorIndexDefinitionContext)

EnterVectorIndexDefinition is called when production vectorIndexDefinition is entered.

func (*BaseRelationalParserListener) EnterVectorIndexOption

func (s *BaseRelationalParserListener) EnterVectorIndexOption(ctx *VectorIndexOptionContext)

EnterVectorIndexOption is called when production vectorIndexOption is entered.

func (*BaseRelationalParserListener) EnterVectorIndexOptionValue

func (s *BaseRelationalParserListener) EnterVectorIndexOptionValue(ctx *VectorIndexOptionValueContext)

EnterVectorIndexOptionValue is called when production vectorIndexOptionValue is entered.

func (*BaseRelationalParserListener) EnterVectorIndexOptions

func (s *BaseRelationalParserListener) EnterVectorIndexOptions(ctx *VectorIndexOptionsContext)

EnterVectorIndexOptions is called when production vectorIndexOptions is entered.

func (*BaseRelationalParserListener) EnterVectorType

func (s *BaseRelationalParserListener) EnterVectorType(ctx *VectorTypeContext)

EnterVectorType is called when production vectorType is entered.

func (*BaseRelationalParserListener) EnterViewDefinition

func (s *BaseRelationalParserListener) EnterViewDefinition(ctx *ViewDefinitionContext)

EnterViewDefinition is called when production viewDefinition is entered.

func (*BaseRelationalParserListener) EnterWeightFunctionCall

func (s *BaseRelationalParserListener) EnterWeightFunctionCall(ctx *WeightFunctionCallContext)

EnterWeightFunctionCall is called when production weightFunctionCall is entered.

func (*BaseRelationalParserListener) EnterWhereExpr

func (s *BaseRelationalParserListener) EnterWhereExpr(ctx *WhereExprContext)

EnterWhereExpr is called when production whereExpr is entered.

func (*BaseRelationalParserListener) EnterWindowName

func (s *BaseRelationalParserListener) EnterWindowName(ctx *WindowNameContext)

EnterWindowName is called when production windowName is entered.

func (*BaseRelationalParserListener) EnterWindowOption

func (s *BaseRelationalParserListener) EnterWindowOption(ctx *WindowOptionContext)

EnterWindowOption is called when production windowOption is entered.

func (*BaseRelationalParserListener) EnterWindowOptionsClause

func (s *BaseRelationalParserListener) EnterWindowOptionsClause(ctx *WindowOptionsClauseContext)

EnterWindowOptionsClause is called when production windowOptionsClause is entered.

func (*BaseRelationalParserListener) EnterWindowSpec

func (s *BaseRelationalParserListener) EnterWindowSpec(ctx *WindowSpecContext)

EnterWindowSpec is called when production windowSpec is entered.

func (*BaseRelationalParserListener) ExitAdministrationStatement

func (s *BaseRelationalParserListener) ExitAdministrationStatement(ctx *AdministrationStatementContext)

ExitAdministrationStatement is called when production administrationStatement is exited.

func (*BaseRelationalParserListener) ExitAggregateFunctionCall

func (s *BaseRelationalParserListener) ExitAggregateFunctionCall(ctx *AggregateFunctionCallContext)

ExitAggregateFunctionCall is called when production aggregateFunctionCall is exited.

func (*BaseRelationalParserListener) ExitAggregateLimitClause

func (s *BaseRelationalParserListener) ExitAggregateLimitClause(ctx *AggregateLimitClauseContext)

ExitAggregateLimitClause is called when production aggregateLimitClause is exited.

func (*BaseRelationalParserListener) ExitAggregateWindowedFunction

func (s *BaseRelationalParserListener) ExitAggregateWindowedFunction(ctx *AggregateWindowedFunctionContext)

ExitAggregateWindowedFunction is called when production aggregateWindowedFunction is exited.

func (*BaseRelationalParserListener) ExitArrayConstructor

func (s *BaseRelationalParserListener) ExitArrayConstructor(ctx *ArrayConstructorContext)

ExitArrayConstructor is called when production arrayConstructor is exited.

func (*BaseRelationalParserListener) ExitArrayConstructorExpressionAtom

func (s *BaseRelationalParserListener) ExitArrayConstructorExpressionAtom(ctx *ArrayConstructorExpressionAtomContext)

ExitArrayConstructorExpressionAtom is called when production arrayConstructorExpressionAtom is exited.

func (*BaseRelationalParserListener) ExitAssignmentField

func (s *BaseRelationalParserListener) ExitAssignmentField(ctx *AssignmentFieldContext)

ExitAssignmentField is called when production assignmentField is exited.

func (*BaseRelationalParserListener) ExitAtomTableItem

func (s *BaseRelationalParserListener) ExitAtomTableItem(ctx *AtomTableItemContext)

ExitAtomTableItem is called when production atomTableItem is exited.

func (*BaseRelationalParserListener) ExitBetweenComparisonPredicate

func (s *BaseRelationalParserListener) ExitBetweenComparisonPredicate(ctx *BetweenComparisonPredicateContext)

ExitBetweenComparisonPredicate is called when production betweenComparisonPredicate is exited.

func (*BaseRelationalParserListener) ExitBinaryComparisonPredicate

func (s *BaseRelationalParserListener) ExitBinaryComparisonPredicate(ctx *BinaryComparisonPredicateContext)

ExitBinaryComparisonPredicate is called when production binaryComparisonPredicate is exited.

func (*BaseRelationalParserListener) ExitBitExpressionAtom

func (s *BaseRelationalParserListener) ExitBitExpressionAtom(ctx *BitExpressionAtomContext)

ExitBitExpressionAtom is called when production bitExpressionAtom is exited.

func (*BaseRelationalParserListener) ExitBitOperator

func (s *BaseRelationalParserListener) ExitBitOperator(ctx *BitOperatorContext)

ExitBitOperator is called when production bitOperator is exited.

func (*BaseRelationalParserListener) ExitBitStringConstant

func (s *BaseRelationalParserListener) ExitBitStringConstant(ctx *BitStringConstantContext)

ExitBitStringConstant is called when production bitStringConstant is exited.

func (*BaseRelationalParserListener) ExitBooleanConstant

func (s *BaseRelationalParserListener) ExitBooleanConstant(ctx *BooleanConstantContext)

ExitBooleanConstant is called when production booleanConstant is exited.

func (*BaseRelationalParserListener) ExitBooleanLiteral

func (s *BaseRelationalParserListener) ExitBooleanLiteral(ctx *BooleanLiteralContext)

ExitBooleanLiteral is called when production booleanLiteral is exited.

func (*BaseRelationalParserListener) ExitBytesConstant

func (s *BaseRelationalParserListener) ExitBytesConstant(ctx *BytesConstantContext)

ExitBytesConstant is called when production bytesConstant is exited.

func (*BaseRelationalParserListener) ExitBytesLiteral

func (s *BaseRelationalParserListener) ExitBytesLiteral(ctx *BytesLiteralContext)

ExitBytesLiteral is called when production bytesLiteral is exited.

func (*BaseRelationalParserListener) ExitCaseExpressionFunctionCall

func (s *BaseRelationalParserListener) ExitCaseExpressionFunctionCall(ctx *CaseExpressionFunctionCallContext)

ExitCaseExpressionFunctionCall is called when production caseExpressionFunctionCall is exited.

func (*BaseRelationalParserListener) ExitCaseFuncAlternative

func (s *BaseRelationalParserListener) ExitCaseFuncAlternative(ctx *CaseFuncAlternativeContext)

ExitCaseFuncAlternative is called when production caseFuncAlternative is exited.

func (*BaseRelationalParserListener) ExitCaseFunctionCall

func (s *BaseRelationalParserListener) ExitCaseFunctionCall(ctx *CaseFunctionCallContext)

ExitCaseFunctionCall is called when production caseFunctionCall is exited.

func (*BaseRelationalParserListener) ExitCharFunctionCall

func (s *BaseRelationalParserListener) ExitCharFunctionCall(ctx *CharFunctionCallContext)

ExitCharFunctionCall is called when production charFunctionCall is exited.

func (*BaseRelationalParserListener) ExitCharSet

func (s *BaseRelationalParserListener) ExitCharSet(ctx *CharSetContext)

ExitCharSet is called when production charSet is exited.

func (*BaseRelationalParserListener) ExitCharsetName

func (s *BaseRelationalParserListener) ExitCharsetName(ctx *CharsetNameContext)

ExitCharsetName is called when production charsetName is exited.

func (*BaseRelationalParserListener) ExitCharsetNameBase

func (s *BaseRelationalParserListener) ExitCharsetNameBase(ctx *CharsetNameBaseContext)

ExitCharsetNameBase is called when production charsetNameBase is exited.

func (*BaseRelationalParserListener) ExitCollationName

func (s *BaseRelationalParserListener) ExitCollationName(ctx *CollationNameContext)

ExitCollationName is called when production collationName is exited.

func (*BaseRelationalParserListener) ExitCollectionDataType

func (s *BaseRelationalParserListener) ExitCollectionDataType(ctx *CollectionDataTypeContext)

ExitCollectionDataType is called when production collectionDataType is exited.

func (*BaseRelationalParserListener) ExitCollectionOptions

func (s *BaseRelationalParserListener) ExitCollectionOptions(ctx *CollectionOptionsContext)

ExitCollectionOptions is called when production collectionOptions is exited.

func (*BaseRelationalParserListener) ExitColumnDefinition

func (s *BaseRelationalParserListener) ExitColumnDefinition(ctx *ColumnDefinitionContext)

ExitColumnDefinition is called when production columnDefinition is exited.

func (*BaseRelationalParserListener) ExitColumnType

func (s *BaseRelationalParserListener) ExitColumnType(ctx *ColumnTypeContext)

ExitColumnType is called when production columnType is exited.

func (*BaseRelationalParserListener) ExitCommitStatement

func (s *BaseRelationalParserListener) ExitCommitStatement(ctx *CommitStatementContext)

ExitCommitStatement is called when production commitStatement is exited.

func (*BaseRelationalParserListener) ExitComparisonOperator

func (s *BaseRelationalParserListener) ExitComparisonOperator(ctx *ComparisonOperatorContext)

ExitComparisonOperator is called when production comparisonOperator is exited.

func (*BaseRelationalParserListener) ExitConstantExpressionAtom

func (s *BaseRelationalParserListener) ExitConstantExpressionAtom(ctx *ConstantExpressionAtomContext)

ExitConstantExpressionAtom is called when production constantExpressionAtom is exited.

func (*BaseRelationalParserListener) ExitContinuationAtom

func (s *BaseRelationalParserListener) ExitContinuationAtom(ctx *ContinuationAtomContext)

ExitContinuationAtom is called when production continuationAtom is exited.

func (*BaseRelationalParserListener) ExitConvertedDataType

func (s *BaseRelationalParserListener) ExitConvertedDataType(ctx *ConvertedDataTypeContext)

ExitConvertedDataType is called when production convertedDataType is exited.

func (*BaseRelationalParserListener) ExitCopyExportStatement

func (s *BaseRelationalParserListener) ExitCopyExportStatement(ctx *CopyExportStatementContext)

ExitCopyExportStatement is called when production copyExportStatement is exited.

func (*BaseRelationalParserListener) ExitCopyImportStatement

func (s *BaseRelationalParserListener) ExitCopyImportStatement(ctx *CopyImportStatementContext)

ExitCopyImportStatement is called when production copyImportStatement is exited.

func (*BaseRelationalParserListener) ExitCreateDatabaseStatement

func (s *BaseRelationalParserListener) ExitCreateDatabaseStatement(ctx *CreateDatabaseStatementContext)

ExitCreateDatabaseStatement is called when production createDatabaseStatement is exited.

func (*BaseRelationalParserListener) ExitCreateSchemaStatement

func (s *BaseRelationalParserListener) ExitCreateSchemaStatement(ctx *CreateSchemaStatementContext)

ExitCreateSchemaStatement is called when production createSchemaStatement is exited.

func (*BaseRelationalParserListener) ExitCreateSchemaTemplateStatement

func (s *BaseRelationalParserListener) ExitCreateSchemaTemplateStatement(ctx *CreateSchemaTemplateStatementContext)

ExitCreateSchemaTemplateStatement is called when production createSchemaTemplateStatement is exited.

func (*BaseRelationalParserListener) ExitCreateTempFunction

func (s *BaseRelationalParserListener) ExitCreateTempFunction(ctx *CreateTempFunctionContext)

ExitCreateTempFunction is called when production createTempFunction is exited.

func (*BaseRelationalParserListener) ExitCtes

func (s *BaseRelationalParserListener) ExitCtes(ctx *CtesContext)

ExitCtes is called when production ctes is exited.

func (*BaseRelationalParserListener) ExitCurrentTimestamp

func (s *BaseRelationalParserListener) ExitCurrentTimestamp(ctx *CurrentTimestampContext)

ExitCurrentTimestamp is called when production currentTimestamp is exited.

func (*BaseRelationalParserListener) ExitDataTypeFunctionCall

func (s *BaseRelationalParserListener) ExitDataTypeFunctionCall(ctx *DataTypeFunctionCallContext)

ExitDataTypeFunctionCall is called when production dataTypeFunctionCall is exited.

func (*BaseRelationalParserListener) ExitDdlStatement

func (s *BaseRelationalParserListener) ExitDdlStatement(ctx *DdlStatementContext)

ExitDdlStatement is called when production ddlStatement is exited.

func (*BaseRelationalParserListener) ExitDecimalConstant

func (s *BaseRelationalParserListener) ExitDecimalConstant(ctx *DecimalConstantContext)

ExitDecimalConstant is called when production decimalConstant is exited.

func (*BaseRelationalParserListener) ExitDecimalLiteral

func (s *BaseRelationalParserListener) ExitDecimalLiteral(ctx *DecimalLiteralContext)

ExitDecimalLiteral is called when production decimalLiteral is exited.

func (*BaseRelationalParserListener) ExitDeclareBlock

func (s *BaseRelationalParserListener) ExitDeclareBlock(ctx *DeclareBlockContext)

ExitDeclareBlock is called when production declareBlock is exited.

func (*BaseRelationalParserListener) ExitDeclaredFunction

func (s *BaseRelationalParserListener) ExitDeclaredFunction(ctx *DeclaredFunctionContext)

ExitDeclaredFunction is called when production declaredFunction is exited.

func (*BaseRelationalParserListener) ExitDefaultValue

func (s *BaseRelationalParserListener) ExitDefaultValue(ctx *DefaultValueContext)

ExitDefaultValue is called when production defaultValue is exited.

func (*BaseRelationalParserListener) ExitDeleteStatement

func (s *BaseRelationalParserListener) ExitDeleteStatement(ctx *DeleteStatementContext)

ExitDeleteStatement is called when production deleteStatement is exited.

func (*BaseRelationalParserListener) ExitDescribeConnection

func (s *BaseRelationalParserListener) ExitDescribeConnection(ctx *DescribeConnectionContext)

ExitDescribeConnection is called when production describeConnection is exited.

func (*BaseRelationalParserListener) ExitDescribeStatements

func (s *BaseRelationalParserListener) ExitDescribeStatements(ctx *DescribeStatementsContext)

ExitDescribeStatements is called when production describeStatements is exited.

func (*BaseRelationalParserListener) ExitDeterministicCharacteristic

func (s *BaseRelationalParserListener) ExitDeterministicCharacteristic(ctx *DeterministicCharacteristicContext)

ExitDeterministicCharacteristic is called when production deterministicCharacteristic is exited.

func (*BaseRelationalParserListener) ExitDimensionDataType

func (s *BaseRelationalParserListener) ExitDimensionDataType(ctx *DimensionDataTypeContext)

ExitDimensionDataType is called when production dimensionDataType is exited.

func (*BaseRelationalParserListener) ExitDispatchClause

func (s *BaseRelationalParserListener) ExitDispatchClause(ctx *DispatchClauseContext)

ExitDispatchClause is called when production dispatchClause is exited.

func (*BaseRelationalParserListener) ExitDmlStatement

func (s *BaseRelationalParserListener) ExitDmlStatement(ctx *DmlStatementContext)

ExitDmlStatement is called when production dmlStatement is exited.

func (*BaseRelationalParserListener) ExitDropDatabaseStatement

func (s *BaseRelationalParserListener) ExitDropDatabaseStatement(ctx *DropDatabaseStatementContext)

ExitDropDatabaseStatement is called when production dropDatabaseStatement is exited.

func (*BaseRelationalParserListener) ExitDropSchemaStatement

func (s *BaseRelationalParserListener) ExitDropSchemaStatement(ctx *DropSchemaStatementContext)

ExitDropSchemaStatement is called when production dropSchemaStatement is exited.

func (*BaseRelationalParserListener) ExitDropSchemaTemplateStatement

func (s *BaseRelationalParserListener) ExitDropSchemaTemplateStatement(ctx *DropSchemaTemplateStatementContext)

ExitDropSchemaTemplateStatement is called when production dropSchemaTemplateStatement is exited.

func (*BaseRelationalParserListener) ExitDropTempFunction

func (s *BaseRelationalParserListener) ExitDropTempFunction(ctx *DropTempFunctionContext)

ExitDropTempFunction is called when production dropTempFunction is exited.

func (*BaseRelationalParserListener) ExitEnumDefinition

func (s *BaseRelationalParserListener) ExitEnumDefinition(ctx *EnumDefinitionContext)

ExitEnumDefinition is called when production enumDefinition is exited.

func (*BaseRelationalParserListener) ExitEveryRule

ExitEveryRule is called when any rule is exited.

func (*BaseRelationalParserListener) ExitExecuteContinuationStatement

func (s *BaseRelationalParserListener) ExitExecuteContinuationStatement(ctx *ExecuteContinuationStatementContext)

ExitExecuteContinuationStatement is called when production executeContinuationStatement is exited.

func (*BaseRelationalParserListener) ExitExecuteStatement

func (s *BaseRelationalParserListener) ExitExecuteStatement(ctx *ExecuteStatementContext)

ExitExecuteStatement is called when production executeStatement is exited.

func (*BaseRelationalParserListener) ExitExistsExpressionAtom

func (s *BaseRelationalParserListener) ExitExistsExpressionAtom(ctx *ExistsExpressionAtomContext)

ExitExistsExpressionAtom is called when production existsExpressionAtom is exited.

func (*BaseRelationalParserListener) ExitExpressionOrDefault

func (s *BaseRelationalParserListener) ExitExpressionOrDefault(ctx *ExpressionOrDefaultContext)

ExitExpressionOrDefault is called when production expressionOrDefault is exited.

func (*BaseRelationalParserListener) ExitExpressionWithOptionalName

func (s *BaseRelationalParserListener) ExitExpressionWithOptionalName(ctx *ExpressionWithOptionalNameContext)

ExitExpressionWithOptionalName is called when production expressionWithOptionalName is exited.

func (*BaseRelationalParserListener) ExitExpressions

func (s *BaseRelationalParserListener) ExitExpressions(ctx *ExpressionsContext)

ExitExpressions is called when production expressions is exited.

func (*BaseRelationalParserListener) ExitExpressionsWithDefaults

func (s *BaseRelationalParserListener) ExitExpressionsWithDefaults(ctx *ExpressionsWithDefaultsContext)

ExitExpressionsWithDefaults is called when production expressionsWithDefaults is exited.

func (*BaseRelationalParserListener) ExitExtractFunctionCall

func (s *BaseRelationalParserListener) ExitExtractFunctionCall(ctx *ExtractFunctionCallContext)

ExitExtractFunctionCall is called when production extractFunctionCall is exited.

func (*BaseRelationalParserListener) ExitFromClause

func (s *BaseRelationalParserListener) ExitFromClause(ctx *FromClauseContext)

ExitFromClause is called when production fromClause is exited.

func (*BaseRelationalParserListener) ExitFullColumnName

func (s *BaseRelationalParserListener) ExitFullColumnName(ctx *FullColumnNameContext)

ExitFullColumnName is called when production fullColumnName is exited.

func (*BaseRelationalParserListener) ExitFullColumnNameExpressionAtom

func (s *BaseRelationalParserListener) ExitFullColumnNameExpressionAtom(ctx *FullColumnNameExpressionAtomContext)

ExitFullColumnNameExpressionAtom is called when production fullColumnNameExpressionAtom is exited.

func (*BaseRelationalParserListener) ExitFullDescribeStatement

func (s *BaseRelationalParserListener) ExitFullDescribeStatement(ctx *FullDescribeStatementContext)

ExitFullDescribeStatement is called when production fullDescribeStatement is exited.

func (*BaseRelationalParserListener) ExitFullId

func (s *BaseRelationalParserListener) ExitFullId(ctx *FullIdContext)

ExitFullId is called when production fullId is exited.

func (*BaseRelationalParserListener) ExitFullIdList

func (s *BaseRelationalParserListener) ExitFullIdList(ctx *FullIdListContext)

ExitFullIdList is called when production fullIdList is exited.

func (*BaseRelationalParserListener) ExitFunctionArg

func (s *BaseRelationalParserListener) ExitFunctionArg(ctx *FunctionArgContext)

ExitFunctionArg is called when production functionArg is exited.

func (*BaseRelationalParserListener) ExitFunctionArgs

func (s *BaseRelationalParserListener) ExitFunctionArgs(ctx *FunctionArgsContext)

ExitFunctionArgs is called when production functionArgs is exited.

func (*BaseRelationalParserListener) ExitFunctionCallExpressionAtom

func (s *BaseRelationalParserListener) ExitFunctionCallExpressionAtom(ctx *FunctionCallExpressionAtomContext)

ExitFunctionCallExpressionAtom is called when production functionCallExpressionAtom is exited.

func (*BaseRelationalParserListener) ExitFunctionColumnType

func (s *BaseRelationalParserListener) ExitFunctionColumnType(ctx *FunctionColumnTypeContext)

ExitFunctionColumnType is called when production functionColumnType is exited.

func (*BaseRelationalParserListener) ExitFunctionNameBase

func (s *BaseRelationalParserListener) ExitFunctionNameBase(ctx *FunctionNameBaseContext)

ExitFunctionNameBase is called when production functionNameBase is exited.

func (*BaseRelationalParserListener) ExitFunctionNameKeyword

func (s *BaseRelationalParserListener) ExitFunctionNameKeyword(ctx *FunctionNameKeywordContext)

ExitFunctionNameKeyword is called when production functionNameKeyword is exited.

func (*BaseRelationalParserListener) ExitFunctionSpecification

func (s *BaseRelationalParserListener) ExitFunctionSpecification(ctx *FunctionSpecificationContext)

ExitFunctionSpecification is called when production functionSpecification is exited.

func (*BaseRelationalParserListener) ExitGetFormatFunctionCall

func (s *BaseRelationalParserListener) ExitGetFormatFunctionCall(ctx *GetFormatFunctionCallContext)

ExitGetFormatFunctionCall is called when production getFormatFunctionCall is exited.

func (*BaseRelationalParserListener) ExitGroupByClause

func (s *BaseRelationalParserListener) ExitGroupByClause(ctx *GroupByClauseContext)

ExitGroupByClause is called when production groupByClause is exited.

func (*BaseRelationalParserListener) ExitGroupByItem

func (s *BaseRelationalParserListener) ExitGroupByItem(ctx *GroupByItemContext)

ExitGroupByItem is called when production groupByItem is exited.

func (*BaseRelationalParserListener) ExitHavingClause

func (s *BaseRelationalParserListener) ExitHavingClause(ctx *HavingClauseContext)

ExitHavingClause is called when production havingClause is exited.

func (*BaseRelationalParserListener) ExitHelpStatement

func (s *BaseRelationalParserListener) ExitHelpStatement(ctx *HelpStatementContext)

ExitHelpStatement is called when production helpStatement is exited.

func (*BaseRelationalParserListener) ExitHnswMetric

func (s *BaseRelationalParserListener) ExitHnswMetric(ctx *HnswMetricContext)

ExitHnswMetric is called when production hnswMetric is exited.

func (*BaseRelationalParserListener) ExitIfExists

func (s *BaseRelationalParserListener) ExitIfExists(ctx *IfExistsContext)

ExitIfExists is called when production ifExists is exited.

func (*BaseRelationalParserListener) ExitIfNotExists

func (s *BaseRelationalParserListener) ExitIfNotExists(ctx *IfNotExistsContext)

ExitIfNotExists is called when production ifNotExists is exited.

func (*BaseRelationalParserListener) ExitInList

func (s *BaseRelationalParserListener) ExitInList(ctx *InListContext)

ExitInList is called when production inList is exited.

func (*BaseRelationalParserListener) ExitInPredicate

func (s *BaseRelationalParserListener) ExitInPredicate(ctx *InPredicateContext)

ExitInPredicate is called when production inPredicate is exited.

func (*BaseRelationalParserListener) ExitIncludeClause

func (s *BaseRelationalParserListener) ExitIncludeClause(ctx *IncludeClauseContext)

ExitIncludeClause is called when production includeClause is exited.

func (*BaseRelationalParserListener) ExitIndexAsSelectDefinition

func (s *BaseRelationalParserListener) ExitIndexAsSelectDefinition(ctx *IndexAsSelectDefinitionContext)

ExitIndexAsSelectDefinition is called when production indexAsSelectDefinition is exited.

func (*BaseRelationalParserListener) ExitIndexAttribute

func (s *BaseRelationalParserListener) ExitIndexAttribute(ctx *IndexAttributeContext)

ExitIndexAttribute is called when production indexAttribute is exited.

func (*BaseRelationalParserListener) ExitIndexAttributes

func (s *BaseRelationalParserListener) ExitIndexAttributes(ctx *IndexAttributesContext)

ExitIndexAttributes is called when production indexAttributes is exited.

func (*BaseRelationalParserListener) ExitIndexColumnList

func (s *BaseRelationalParserListener) ExitIndexColumnList(ctx *IndexColumnListContext)

ExitIndexColumnList is called when production indexColumnList is exited.

func (*BaseRelationalParserListener) ExitIndexColumnName

func (s *BaseRelationalParserListener) ExitIndexColumnName(ctx *IndexColumnNameContext)

ExitIndexColumnName is called when production indexColumnName is exited.

func (*BaseRelationalParserListener) ExitIndexColumnNames

func (s *BaseRelationalParserListener) ExitIndexColumnNames(ctx *IndexColumnNamesContext)

ExitIndexColumnNames is called when production indexColumnNames is exited.

func (*BaseRelationalParserListener) ExitIndexColumnSpec

func (s *BaseRelationalParserListener) ExitIndexColumnSpec(ctx *IndexColumnSpecContext)

ExitIndexColumnSpec is called when production indexColumnSpec is exited.

func (*BaseRelationalParserListener) ExitIndexHint

func (s *BaseRelationalParserListener) ExitIndexHint(ctx *IndexHintContext)

ExitIndexHint is called when production indexHint is exited.

func (*BaseRelationalParserListener) ExitIndexHintType

func (s *BaseRelationalParserListener) ExitIndexHintType(ctx *IndexHintTypeContext)

ExitIndexHintType is called when production indexHintType is exited.

func (*BaseRelationalParserListener) ExitIndexOnSourceDefinition

func (s *BaseRelationalParserListener) ExitIndexOnSourceDefinition(ctx *IndexOnSourceDefinitionContext)

ExitIndexOnSourceDefinition is called when production indexOnSourceDefinition is exited.

func (*BaseRelationalParserListener) ExitIndexOption

func (s *BaseRelationalParserListener) ExitIndexOption(ctx *IndexOptionContext)

ExitIndexOption is called when production indexOption is exited.

func (*BaseRelationalParserListener) ExitIndexOptions

func (s *BaseRelationalParserListener) ExitIndexOptions(ctx *IndexOptionsContext)

ExitIndexOptions is called when production indexOptions is exited.

func (*BaseRelationalParserListener) ExitIndexPartitionClause

func (s *BaseRelationalParserListener) ExitIndexPartitionClause(ctx *IndexPartitionClauseContext)

ExitIndexPartitionClause is called when production indexPartitionClause is exited.

func (*BaseRelationalParserListener) ExitIndexType

func (s *BaseRelationalParserListener) ExitIndexType(ctx *IndexTypeContext)

ExitIndexType is called when production indexType is exited.

func (*BaseRelationalParserListener) ExitInlineTableDefinition

func (s *BaseRelationalParserListener) ExitInlineTableDefinition(ctx *InlineTableDefinitionContext)

ExitInlineTableDefinition is called when production inlineTableDefinition is exited.

func (*BaseRelationalParserListener) ExitInlineTableItem

func (s *BaseRelationalParserListener) ExitInlineTableItem(ctx *InlineTableItemContext)

ExitInlineTableItem is called when production inlineTableItem is exited.

func (*BaseRelationalParserListener) ExitInnerJoin

func (s *BaseRelationalParserListener) ExitInnerJoin(ctx *InnerJoinContext)

ExitInnerJoin is called when production innerJoin is exited.

func (*BaseRelationalParserListener) ExitInsertStatement

func (s *BaseRelationalParserListener) ExitInsertStatement(ctx *InsertStatementContext)

ExitInsertStatement is called when production insertStatement is exited.

func (*BaseRelationalParserListener) ExitInsertStatementValueSelect

func (s *BaseRelationalParserListener) ExitInsertStatementValueSelect(ctx *InsertStatementValueSelectContext)

ExitInsertStatementValueSelect is called when production insertStatementValueSelect is exited.

func (*BaseRelationalParserListener) ExitInsertStatementValueValues

func (s *BaseRelationalParserListener) ExitInsertStatementValueValues(ctx *InsertStatementValueValuesContext)

ExitInsertStatementValueValues is called when production insertStatementValueValues is exited.

func (*BaseRelationalParserListener) ExitIntervalType

func (s *BaseRelationalParserListener) ExitIntervalType(ctx *IntervalTypeContext)

ExitIntervalType is called when production intervalType is exited.

func (*BaseRelationalParserListener) ExitIntervalTypeBase

func (s *BaseRelationalParserListener) ExitIntervalTypeBase(ctx *IntervalTypeBaseContext)

ExitIntervalTypeBase is called when production intervalTypeBase is exited.

func (*BaseRelationalParserListener) ExitIsExpression

func (s *BaseRelationalParserListener) ExitIsExpression(ctx *IsExpressionContext)

ExitIsExpression is called when production isExpression is exited.

func (*BaseRelationalParserListener) ExitJsonOperator

func (s *BaseRelationalParserListener) ExitJsonOperator(ctx *JsonOperatorContext)

ExitJsonOperator is called when production jsonOperator is exited.

func (*BaseRelationalParserListener) ExitKeywordsCanBeId

func (s *BaseRelationalParserListener) ExitKeywordsCanBeId(ctx *KeywordsCanBeIdContext)

ExitKeywordsCanBeId is called when production keywordsCanBeId is exited.

func (*BaseRelationalParserListener) ExitKillStatement

func (s *BaseRelationalParserListener) ExitKillStatement(ctx *KillStatementContext)

ExitKillStatement is called when production killStatement is exited.

func (*BaseRelationalParserListener) ExitLanguageClause

func (s *BaseRelationalParserListener) ExitLanguageClause(ctx *LanguageClauseContext)

ExitLanguageClause is called when production languageClause is exited.

func (*BaseRelationalParserListener) ExitLanguageName

func (s *BaseRelationalParserListener) ExitLanguageName(ctx *LanguageNameContext)

ExitLanguageName is called when production languageName is exited.

func (*BaseRelationalParserListener) ExitLengthOneDimension

func (s *BaseRelationalParserListener) ExitLengthOneDimension(ctx *LengthOneDimensionContext)

ExitLengthOneDimension is called when production lengthOneDimension is exited.

func (*BaseRelationalParserListener) ExitLengthTwoDimension

func (s *BaseRelationalParserListener) ExitLengthTwoDimension(ctx *LengthTwoDimensionContext)

ExitLengthTwoDimension is called when production lengthTwoDimension is exited.

func (*BaseRelationalParserListener) ExitLengthTwoOptionalDimension

func (s *BaseRelationalParserListener) ExitLengthTwoOptionalDimension(ctx *LengthTwoOptionalDimensionContext)

ExitLengthTwoOptionalDimension is called when production lengthTwoOptionalDimension is exited.

func (*BaseRelationalParserListener) ExitLevelInWeightListElement

func (s *BaseRelationalParserListener) ExitLevelInWeightListElement(ctx *LevelInWeightListElementContext)

ExitLevelInWeightListElement is called when production levelInWeightListElement is exited.

func (*BaseRelationalParserListener) ExitLevelWeightList

func (s *BaseRelationalParserListener) ExitLevelWeightList(ctx *LevelWeightListContext)

ExitLevelWeightList is called when production levelWeightList is exited.

func (*BaseRelationalParserListener) ExitLevelWeightRange

func (s *BaseRelationalParserListener) ExitLevelWeightRange(ctx *LevelWeightRangeContext)

ExitLevelWeightRange is called when production levelWeightRange is exited.

func (*BaseRelationalParserListener) ExitLikePredicate

func (s *BaseRelationalParserListener) ExitLikePredicate(ctx *LikePredicateContext)

ExitLikePredicate is called when production likePredicate is exited.

func (*BaseRelationalParserListener) ExitLimitClause

func (s *BaseRelationalParserListener) ExitLimitClause(ctx *LimitClauseContext)

ExitLimitClause is called when production limitClause is exited.

func (*BaseRelationalParserListener) ExitLimitClauseAtom

func (s *BaseRelationalParserListener) ExitLimitClauseAtom(ctx *LimitClauseAtomContext)

ExitLimitClauseAtom is called when production limitClauseAtom is exited.

func (*BaseRelationalParserListener) ExitLoadedTableIndexes

func (s *BaseRelationalParserListener) ExitLoadedTableIndexes(ctx *LoadedTableIndexesContext)

ExitLoadedTableIndexes is called when production loadedTableIndexes is exited.

func (*BaseRelationalParserListener) ExitLogicalExpression

func (s *BaseRelationalParserListener) ExitLogicalExpression(ctx *LogicalExpressionContext)

ExitLogicalExpression is called when production logicalExpression is exited.

func (*BaseRelationalParserListener) ExitLogicalOperator

func (s *BaseRelationalParserListener) ExitLogicalOperator(ctx *LogicalOperatorContext)

ExitLogicalOperator is called when production logicalOperator is exited.

func (*BaseRelationalParserListener) ExitLongVarbinaryDataType

func (s *BaseRelationalParserListener) ExitLongVarbinaryDataType(ctx *LongVarbinaryDataTypeContext)

ExitLongVarbinaryDataType is called when production longVarbinaryDataType is exited.

func (*BaseRelationalParserListener) ExitLongVarcharDataType

func (s *BaseRelationalParserListener) ExitLongVarcharDataType(ctx *LongVarcharDataTypeContext)

ExitLongVarcharDataType is called when production longVarcharDataType is exited.

func (*BaseRelationalParserListener) ExitMathExpressionAtom

func (s *BaseRelationalParserListener) ExitMathExpressionAtom(ctx *MathExpressionAtomContext)

ExitMathExpressionAtom is called when production mathExpressionAtom is exited.

func (*BaseRelationalParserListener) ExitMathOperator

func (s *BaseRelationalParserListener) ExitMathOperator(ctx *MathOperatorContext)

ExitMathOperator is called when production mathOperator is exited.

func (*BaseRelationalParserListener) ExitNamedFunctionArg

func (s *BaseRelationalParserListener) ExitNamedFunctionArg(ctx *NamedFunctionArgContext)

ExitNamedFunctionArg is called when production namedFunctionArg is exited.

func (*BaseRelationalParserListener) ExitNamedOrUnnamedFunctionArgs

func (s *BaseRelationalParserListener) ExitNamedOrUnnamedFunctionArgs(ctx *NamedOrUnnamedFunctionArgsContext)

ExitNamedOrUnnamedFunctionArgs is called when production namedOrUnnamedFunctionArgs is exited.

func (*BaseRelationalParserListener) ExitNamedQuery

func (s *BaseRelationalParserListener) ExitNamedQuery(ctx *NamedQueryContext)

ExitNamedQuery is called when production namedQuery is exited.

func (*BaseRelationalParserListener) ExitNationalStringDataType

func (s *BaseRelationalParserListener) ExitNationalStringDataType(ctx *NationalStringDataTypeContext)

ExitNationalStringDataType is called when production nationalStringDataType is exited.

func (*BaseRelationalParserListener) ExitNationalVaryingStringDataType

func (s *BaseRelationalParserListener) ExitNationalVaryingStringDataType(ctx *NationalVaryingStringDataTypeContext)

ExitNationalVaryingStringDataType is called when production nationalVaryingStringDataType is exited.

func (*BaseRelationalParserListener) ExitNaturalJoin

func (s *BaseRelationalParserListener) ExitNaturalJoin(ctx *NaturalJoinContext)

ExitNaturalJoin is called when production naturalJoin is exited.

func (*BaseRelationalParserListener) ExitNegativeDecimalConstant

func (s *BaseRelationalParserListener) ExitNegativeDecimalConstant(ctx *NegativeDecimalConstantContext)

ExitNegativeDecimalConstant is called when production negativeDecimalConstant is exited.

func (*BaseRelationalParserListener) ExitNonAggregateFunctionCall

func (s *BaseRelationalParserListener) ExitNonAggregateFunctionCall(ctx *NonAggregateFunctionCallContext)

ExitNonAggregateFunctionCall is called when production nonAggregateFunctionCall is exited.

func (*BaseRelationalParserListener) ExitNonAggregateWindowedFunction

func (s *BaseRelationalParserListener) ExitNonAggregateWindowedFunction(ctx *NonAggregateWindowedFunctionContext)

ExitNonAggregateWindowedFunction is called when production nonAggregateWindowedFunction is exited.

func (*BaseRelationalParserListener) ExitNotExpression

func (s *BaseRelationalParserListener) ExitNotExpression(ctx *NotExpressionContext)

ExitNotExpression is called when production notExpression is exited.

func (*BaseRelationalParserListener) ExitNullCallClause

func (s *BaseRelationalParserListener) ExitNullCallClause(ctx *NullCallClauseContext)

ExitNullCallClause is called when production nullCallClause is exited.

func (*BaseRelationalParserListener) ExitNullColumnConstraint

func (s *BaseRelationalParserListener) ExitNullColumnConstraint(ctx *NullColumnConstraintContext)

ExitNullColumnConstraint is called when production nullColumnConstraint is exited.

func (*BaseRelationalParserListener) ExitNullConstant

func (s *BaseRelationalParserListener) ExitNullConstant(ctx *NullConstantContext)

ExitNullConstant is called when production nullConstant is exited.

func (*BaseRelationalParserListener) ExitNullLiteral

func (s *BaseRelationalParserListener) ExitNullLiteral(ctx *NullLiteralContext)

ExitNullLiteral is called when production nullLiteral is exited.

func (*BaseRelationalParserListener) ExitNullNotnull

func (s *BaseRelationalParserListener) ExitNullNotnull(ctx *NullNotnullContext)

ExitNullNotnull is called when production nullNotnull is exited.

func (*BaseRelationalParserListener) ExitNullTreatmentClause

func (s *BaseRelationalParserListener) ExitNullTreatmentClause(ctx *NullTreatmentClauseContext)

ExitNullTreatmentClause is called when production nullTreatmentClause is exited.

func (*BaseRelationalParserListener) ExitOfTypeClause

func (s *BaseRelationalParserListener) ExitOfTypeClause(ctx *OfTypeClauseContext)

ExitOfTypeClause is called when production ofTypeClause is exited.

func (*BaseRelationalParserListener) ExitOption

func (s *BaseRelationalParserListener) ExitOption(ctx *OptionContext)

ExitOption is called when production option is exited.

func (*BaseRelationalParserListener) ExitOptionsClause

func (s *BaseRelationalParserListener) ExitOptionsClause(ctx *OptionsClauseContext)

ExitOptionsClause is called when production optionsClause is exited.

func (*BaseRelationalParserListener) ExitOrderByClause

func (s *BaseRelationalParserListener) ExitOrderByClause(ctx *OrderByClauseContext)

ExitOrderByClause is called when production orderByClause is exited.

func (*BaseRelationalParserListener) ExitOrderByExpression

func (s *BaseRelationalParserListener) ExitOrderByExpression(ctx *OrderByExpressionContext)

ExitOrderByExpression is called when production orderByExpression is exited.

func (*BaseRelationalParserListener) ExitOrderClause

func (s *BaseRelationalParserListener) ExitOrderClause(ctx *OrderClauseContext)

ExitOrderClause is called when production orderClause is exited.

func (*BaseRelationalParserListener) ExitOuterJoin

func (s *BaseRelationalParserListener) ExitOuterJoin(ctx *OuterJoinContext)

ExitOuterJoin is called when production outerJoin is exited.

func (*BaseRelationalParserListener) ExitOverClause

func (s *BaseRelationalParserListener) ExitOverClause(ctx *OverClauseContext)

ExitOverClause is called when production overClause is exited.

func (*BaseRelationalParserListener) ExitParameterMode

func (s *BaseRelationalParserListener) ExitParameterMode(ctx *ParameterModeContext)

ExitParameterMode is called when production parameterMode is exited.

func (*BaseRelationalParserListener) ExitParameterStyle

func (s *BaseRelationalParserListener) ExitParameterStyle(ctx *ParameterStyleContext)

ExitParameterStyle is called when production parameterStyle is exited.

func (*BaseRelationalParserListener) ExitParenthesisQuery

func (s *BaseRelationalParserListener) ExitParenthesisQuery(ctx *ParenthesisQueryContext)

ExitParenthesisQuery is called when production parenthesisQuery is exited.

func (*BaseRelationalParserListener) ExitPartitionClause

func (s *BaseRelationalParserListener) ExitPartitionClause(ctx *PartitionClauseContext)

ExitPartitionClause is called when production partitionClause is exited.

func (*BaseRelationalParserListener) ExitPath

func (s *BaseRelationalParserListener) ExitPath(ctx *PathContext)

ExitPath is called when production path is exited.

func (*BaseRelationalParserListener) ExitPositionFunctionCall

func (s *BaseRelationalParserListener) ExitPositionFunctionCall(ctx *PositionFunctionCallContext)

ExitPositionFunctionCall is called when production positionFunctionCall is exited.

func (*BaseRelationalParserListener) ExitPredicatedExpression

func (s *BaseRelationalParserListener) ExitPredicatedExpression(ctx *PredicatedExpressionContext)

ExitPredicatedExpression is called when production predicatedExpression is exited.

func (*BaseRelationalParserListener) ExitPrepareStatement

func (s *BaseRelationalParserListener) ExitPrepareStatement(ctx *PrepareStatementContext)

ExitPrepareStatement is called when production prepareStatement is exited.

func (*BaseRelationalParserListener) ExitPreparedStatement

func (s *BaseRelationalParserListener) ExitPreparedStatement(ctx *PreparedStatementContext)

ExitPreparedStatement is called when production preparedStatement is exited.

func (*BaseRelationalParserListener) ExitPreparedStatementParameter

func (s *BaseRelationalParserListener) ExitPreparedStatementParameter(ctx *PreparedStatementParameterContext)

ExitPreparedStatementParameter is called when production preparedStatementParameter is exited.

func (*BaseRelationalParserListener) ExitPreparedStatementParameterAtom

func (s *BaseRelationalParserListener) ExitPreparedStatementParameterAtom(ctx *PreparedStatementParameterAtomContext)

ExitPreparedStatementParameterAtom is called when production preparedStatementParameterAtom is exited.

func (*BaseRelationalParserListener) ExitPrimaryKeyDefinition

func (s *BaseRelationalParserListener) ExitPrimaryKeyDefinition(ctx *PrimaryKeyDefinitionContext)

ExitPrimaryKeyDefinition is called when production primaryKeyDefinition is exited.

func (*BaseRelationalParserListener) ExitPrimitiveType

func (s *BaseRelationalParserListener) ExitPrimitiveType(ctx *PrimitiveTypeContext)

ExitPrimitiveType is called when production primitiveType is exited.

func (*BaseRelationalParserListener) ExitQualifyClause

func (s *BaseRelationalParserListener) ExitQualifyClause(ctx *QualifyClauseContext)

ExitQualifyClause is called when production qualifyClause is exited.

func (*BaseRelationalParserListener) ExitQuery

func (s *BaseRelationalParserListener) ExitQuery(ctx *QueryContext)

ExitQuery is called when production query is exited.

func (*BaseRelationalParserListener) ExitQueryTermDefault

func (s *BaseRelationalParserListener) ExitQueryTermDefault(ctx *QueryTermDefaultContext)

ExitQueryTermDefault is called when production queryTermDefault is exited.

func (*BaseRelationalParserListener) ExitRecordConstructor

func (s *BaseRelationalParserListener) ExitRecordConstructor(ctx *RecordConstructorContext)

ExitRecordConstructor is called when production recordConstructor is exited.

func (*BaseRelationalParserListener) ExitRecordConstructorExpressionAtom

func (s *BaseRelationalParserListener) ExitRecordConstructorExpressionAtom(ctx *RecordConstructorExpressionAtomContext)

ExitRecordConstructorExpressionAtom is called when production recordConstructorExpressionAtom is exited.

func (*BaseRelationalParserListener) ExitRecordConstructorForInlineTable

func (s *BaseRelationalParserListener) ExitRecordConstructorForInlineTable(ctx *RecordConstructorForInlineTableContext)

ExitRecordConstructorForInlineTable is called when production recordConstructorForInlineTable is exited.

func (*BaseRelationalParserListener) ExitRecordConstructorForInsert

func (s *BaseRelationalParserListener) ExitRecordConstructorForInsert(ctx *RecordConstructorForInsertContext)

ExitRecordConstructorForInsert is called when production recordConstructorForInsert is exited.

func (*BaseRelationalParserListener) ExitResetStatement

func (s *BaseRelationalParserListener) ExitResetStatement(ctx *ResetStatementContext)

ExitResetStatement is called when production resetStatement is exited.

func (*BaseRelationalParserListener) ExitReturnsClause

func (s *BaseRelationalParserListener) ExitReturnsClause(ctx *ReturnsClauseContext)

ExitReturnsClause is called when production returnsClause is exited.

func (*BaseRelationalParserListener) ExitReturnsTableType

func (s *BaseRelationalParserListener) ExitReturnsTableType(ctx *ReturnsTableTypeContext)

ExitReturnsTableType is called when production returnsTableType is exited.

func (*BaseRelationalParserListener) ExitReturnsType

func (s *BaseRelationalParserListener) ExitReturnsType(ctx *ReturnsTypeContext)

ExitReturnsType is called when production returnsType is exited.

func (*BaseRelationalParserListener) ExitRollbackStatement

func (s *BaseRelationalParserListener) ExitRollbackStatement(ctx *RollbackStatementContext)

ExitRollbackStatement is called when production rollbackStatement is exited.

func (*BaseRelationalParserListener) ExitRoot

func (s *BaseRelationalParserListener) ExitRoot(ctx *RootContext)

ExitRoot is called when production root is exited.

func (*BaseRelationalParserListener) ExitRoutineCharacteristics

func (s *BaseRelationalParserListener) ExitRoutineCharacteristics(ctx *RoutineCharacteristicsContext)

ExitRoutineCharacteristics is called when production routineCharacteristics is exited.

func (*BaseRelationalParserListener) ExitScalarFunctionCall

func (s *BaseRelationalParserListener) ExitScalarFunctionCall(ctx *ScalarFunctionCallContext)

ExitScalarFunctionCall is called when production scalarFunctionCall is exited.

func (*BaseRelationalParserListener) ExitScalarFunctionName

func (s *BaseRelationalParserListener) ExitScalarFunctionName(ctx *ScalarFunctionNameContext)

ExitScalarFunctionName is called when production scalarFunctionName is exited.

func (*BaseRelationalParserListener) ExitSchemaId

func (s *BaseRelationalParserListener) ExitSchemaId(ctx *SchemaIdContext)

ExitSchemaId is called when production schemaId is exited.

func (*BaseRelationalParserListener) ExitSchemaTemplateId

func (s *BaseRelationalParserListener) ExitSchemaTemplateId(ctx *SchemaTemplateIdContext)

ExitSchemaTemplateId is called when production schemaTemplateId is exited.

func (*BaseRelationalParserListener) ExitSelectElements

func (s *BaseRelationalParserListener) ExitSelectElements(ctx *SelectElementsContext)

ExitSelectElements is called when production selectElements is exited.

func (*BaseRelationalParserListener) ExitSelectExpressionElement

func (s *BaseRelationalParserListener) ExitSelectExpressionElement(ctx *SelectExpressionElementContext)

ExitSelectExpressionElement is called when production selectExpressionElement is exited.

func (*BaseRelationalParserListener) ExitSelectQualifierStarElement

func (s *BaseRelationalParserListener) ExitSelectQualifierStarElement(ctx *SelectQualifierStarElementContext)

ExitSelectQualifierStarElement is called when production selectQualifierStarElement is exited.

func (*BaseRelationalParserListener) ExitSelectStarElement

func (s *BaseRelationalParserListener) ExitSelectStarElement(ctx *SelectStarElementContext)

ExitSelectStarElement is called when production selectStarElement is exited.

func (*BaseRelationalParserListener) ExitSelectStatement

func (s *BaseRelationalParserListener) ExitSelectStatement(ctx *SelectStatementContext)

ExitSelectStatement is called when production selectStatement is exited.

func (*BaseRelationalParserListener) ExitSetAutocommit

func (s *BaseRelationalParserListener) ExitSetAutocommit(ctx *SetAutocommitContext)

ExitSetAutocommit is called when production setAutocommit is exited.

func (*BaseRelationalParserListener) ExitSetAutocommitStatement

func (s *BaseRelationalParserListener) ExitSetAutocommitStatement(ctx *SetAutocommitStatementContext)

ExitSetAutocommitStatement is called when production setAutocommitStatement is exited.

func (*BaseRelationalParserListener) ExitSetCharset

func (s *BaseRelationalParserListener) ExitSetCharset(ctx *SetCharsetContext)

ExitSetCharset is called when production setCharset is exited.

func (*BaseRelationalParserListener) ExitSetNames

func (s *BaseRelationalParserListener) ExitSetNames(ctx *SetNamesContext)

ExitSetNames is called when production setNames is exited.

func (*BaseRelationalParserListener) ExitSetNewValueInsideTrigger

func (s *BaseRelationalParserListener) ExitSetNewValueInsideTrigger(ctx *SetNewValueInsideTriggerContext)

ExitSetNewValueInsideTrigger is called when production setNewValueInsideTrigger is exited.

func (*BaseRelationalParserListener) ExitSetQuery

func (s *BaseRelationalParserListener) ExitSetQuery(ctx *SetQueryContext)

ExitSetQuery is called when production setQuery is exited.

func (*BaseRelationalParserListener) ExitSetTransaction

func (s *BaseRelationalParserListener) ExitSetTransaction(ctx *SetTransactionContext)

ExitSetTransaction is called when production setTransaction is exited.

func (*BaseRelationalParserListener) ExitSetTransactionStatement

func (s *BaseRelationalParserListener) ExitSetTransactionStatement(ctx *SetTransactionStatementContext)

ExitSetTransactionStatement is called when production setTransactionStatement is exited.

func (*BaseRelationalParserListener) ExitSetVariable

func (s *BaseRelationalParserListener) ExitSetVariable(ctx *SetVariableContext)

ExitSetVariable is called when production setVariable is exited.

func (*BaseRelationalParserListener) ExitShowDatabasesStatement

func (s *BaseRelationalParserListener) ExitShowDatabasesStatement(ctx *ShowDatabasesStatementContext)

ExitShowDatabasesStatement is called when production showDatabasesStatement is exited.

func (*BaseRelationalParserListener) ExitShowSchemaTemplatesStatement

func (s *BaseRelationalParserListener) ExitShowSchemaTemplatesStatement(ctx *ShowSchemaTemplatesStatementContext)

ExitShowSchemaTemplatesStatement is called when production showSchemaTemplatesStatement is exited.

func (*BaseRelationalParserListener) ExitSimpleDataType

func (s *BaseRelationalParserListener) ExitSimpleDataType(ctx *SimpleDataTypeContext)

ExitSimpleDataType is called when production simpleDataType is exited.

func (*BaseRelationalParserListener) ExitSimpleDescribeSchemaStatement

func (s *BaseRelationalParserListener) ExitSimpleDescribeSchemaStatement(ctx *SimpleDescribeSchemaStatementContext)

ExitSimpleDescribeSchemaStatement is called when production simpleDescribeSchemaStatement is exited.

func (*BaseRelationalParserListener) ExitSimpleDescribeSchemaTemplateStatement

func (s *BaseRelationalParserListener) ExitSimpleDescribeSchemaTemplateStatement(ctx *SimpleDescribeSchemaTemplateStatementContext)

ExitSimpleDescribeSchemaTemplateStatement is called when production simpleDescribeSchemaTemplateStatement is exited.

func (*BaseRelationalParserListener) ExitSimpleFunctionCall

func (s *BaseRelationalParserListener) ExitSimpleFunctionCall(ctx *SimpleFunctionCallContext)

ExitSimpleFunctionCall is called when production simpleFunctionCall is exited.

func (*BaseRelationalParserListener) ExitSimpleId

func (s *BaseRelationalParserListener) ExitSimpleId(ctx *SimpleIdContext)

ExitSimpleId is called when production simpleId is exited.

func (*BaseRelationalParserListener) ExitSimpleTable

func (s *BaseRelationalParserListener) ExitSimpleTable(ctx *SimpleTableContext)

ExitSimpleTable is called when production simpleTable is exited.

func (*BaseRelationalParserListener) ExitSpatialDataType

func (s *BaseRelationalParserListener) ExitSpatialDataType(ctx *SpatialDataTypeContext)

ExitSpatialDataType is called when production spatialDataType is exited.

func (*BaseRelationalParserListener) ExitSpecificFunctionCall

func (s *BaseRelationalParserListener) ExitSpecificFunctionCall(ctx *SpecificFunctionCallContext)

ExitSpecificFunctionCall is called when production specificFunctionCall is exited.

func (*BaseRelationalParserListener) ExitSqlInvokedFunction

func (s *BaseRelationalParserListener) ExitSqlInvokedFunction(ctx *SqlInvokedFunctionContext)

ExitSqlInvokedFunction is called when production sqlInvokedFunction is exited.

func (*BaseRelationalParserListener) ExitSqlParameterDeclaration

func (s *BaseRelationalParserListener) ExitSqlParameterDeclaration(ctx *SqlParameterDeclarationContext)

ExitSqlParameterDeclaration is called when production sqlParameterDeclaration is exited.

func (*BaseRelationalParserListener) ExitSqlParameterDeclarationList

func (s *BaseRelationalParserListener) ExitSqlParameterDeclarationList(ctx *SqlParameterDeclarationListContext)

ExitSqlParameterDeclarationList is called when production sqlParameterDeclarationList is exited.

func (*BaseRelationalParserListener) ExitSqlParameterDeclarations

func (s *BaseRelationalParserListener) ExitSqlParameterDeclarations(ctx *SqlParameterDeclarationsContext)

ExitSqlParameterDeclarations is called when production sqlParameterDeclarations is exited.

func (*BaseRelationalParserListener) ExitStartTransaction

func (s *BaseRelationalParserListener) ExitStartTransaction(ctx *StartTransactionContext)

ExitStartTransaction is called when production startTransaction is exited.

func (*BaseRelationalParserListener) ExitStatement

func (s *BaseRelationalParserListener) ExitStatement(ctx *StatementContext)

ExitStatement is called when production statement is exited.

func (*BaseRelationalParserListener) ExitStatementBody

func (s *BaseRelationalParserListener) ExitStatementBody(ctx *StatementBodyContext)

ExitStatementBody is called when production statementBody is exited.

func (*BaseRelationalParserListener) ExitStatementOption

func (s *BaseRelationalParserListener) ExitStatementOption(ctx *StatementOptionContext)

ExitStatementOption is called when production statementOption is exited.

func (*BaseRelationalParserListener) ExitStatementOptions

func (s *BaseRelationalParserListener) ExitStatementOptions(ctx *StatementOptionsContext)

ExitStatementOptions is called when production statementOptions is exited.

func (*BaseRelationalParserListener) ExitStatements

func (s *BaseRelationalParserListener) ExitStatements(ctx *StatementsContext)

ExitStatements is called when production statements is exited.

func (*BaseRelationalParserListener) ExitStoredQueryDefinition

func (s *BaseRelationalParserListener) ExitStoredQueryDefinition(ctx *StoredQueryDefinitionContext)

ExitStoredQueryDefinition is called when production storedQueryDefinition is exited.

func (*BaseRelationalParserListener) ExitStraightJoin

func (s *BaseRelationalParserListener) ExitStraightJoin(ctx *StraightJoinContext)

ExitStraightJoin is called when production straightJoin is exited.

func (*BaseRelationalParserListener) ExitStringConstant

func (s *BaseRelationalParserListener) ExitStringConstant(ctx *StringConstantContext)

ExitStringConstant is called when production stringConstant is exited.

func (*BaseRelationalParserListener) ExitStringDataType

func (s *BaseRelationalParserListener) ExitStringDataType(ctx *StringDataTypeContext)

ExitStringDataType is called when production stringDataType is exited.

func (*BaseRelationalParserListener) ExitStringLiteral

func (s *BaseRelationalParserListener) ExitStringLiteral(ctx *StringLiteralContext)

ExitStringLiteral is called when production stringLiteral is exited.

func (*BaseRelationalParserListener) ExitStructDefinition

func (s *BaseRelationalParserListener) ExitStructDefinition(ctx *StructDefinitionContext)

ExitStructDefinition is called when production structDefinition is exited.

func (*BaseRelationalParserListener) ExitSubqueryExpressionAtom

func (s *BaseRelationalParserListener) ExitSubqueryExpressionAtom(ctx *SubqueryExpressionAtomContext)

ExitSubqueryExpressionAtom is called when production subqueryExpressionAtom is exited.

func (*BaseRelationalParserListener) ExitSubqueryTableItem

func (s *BaseRelationalParserListener) ExitSubqueryTableItem(ctx *SubqueryTableItemContext)

ExitSubqueryTableItem is called when production subqueryTableItem is exited.

func (*BaseRelationalParserListener) ExitSubscriptExpression

func (s *BaseRelationalParserListener) ExitSubscriptExpression(ctx *SubscriptExpressionContext)

ExitSubscriptExpression is called when production subscriptExpression is exited.

func (*BaseRelationalParserListener) ExitSubstrFunctionCall

func (s *BaseRelationalParserListener) ExitSubstrFunctionCall(ctx *SubstrFunctionCallContext)

ExitSubstrFunctionCall is called when production substrFunctionCall is exited.

func (*BaseRelationalParserListener) ExitTableDefinition

func (s *BaseRelationalParserListener) ExitTableDefinition(ctx *TableDefinitionContext)

ExitTableDefinition is called when production tableDefinition is exited.

func (*BaseRelationalParserListener) ExitTableFunction

func (s *BaseRelationalParserListener) ExitTableFunction(ctx *TableFunctionContext)

ExitTableFunction is called when production tableFunction is exited.

func (*BaseRelationalParserListener) ExitTableFunctionColumnList

func (s *BaseRelationalParserListener) ExitTableFunctionColumnList(ctx *TableFunctionColumnListContext)

ExitTableFunctionColumnList is called when production tableFunctionColumnList is exited.

func (*BaseRelationalParserListener) ExitTableFunctionColumnListElement

func (s *BaseRelationalParserListener) ExitTableFunctionColumnListElement(ctx *TableFunctionColumnListElementContext)

ExitTableFunctionColumnListElement is called when production tableFunctionColumnListElement is exited.

func (*BaseRelationalParserListener) ExitTableFunctionName

func (s *BaseRelationalParserListener) ExitTableFunctionName(ctx *TableFunctionNameContext)

ExitTableFunctionName is called when production tableFunctionName is exited.

func (*BaseRelationalParserListener) ExitTableIndexes

func (s *BaseRelationalParserListener) ExitTableIndexes(ctx *TableIndexesContext)

ExitTableIndexes is called when production tableIndexes is exited.

func (*BaseRelationalParserListener) ExitTableName

func (s *BaseRelationalParserListener) ExitTableName(ctx *TableNameContext)

ExitTableName is called when production tableName is exited.

func (*BaseRelationalParserListener) ExitTableSourceBase

func (s *BaseRelationalParserListener) ExitTableSourceBase(ctx *TableSourceBaseContext)

ExitTableSourceBase is called when production tableSourceBase is exited.

func (*BaseRelationalParserListener) ExitTableSources

func (s *BaseRelationalParserListener) ExitTableSources(ctx *TableSourcesContext)

ExitTableSources is called when production tableSources is exited.

func (*BaseRelationalParserListener) ExitTableValuedFunction

func (s *BaseRelationalParserListener) ExitTableValuedFunction(ctx *TableValuedFunctionContext)

ExitTableValuedFunction is called when production tableValuedFunction is exited.

func (*BaseRelationalParserListener) ExitTables

func (s *BaseRelationalParserListener) ExitTables(ctx *TablesContext)

ExitTables is called when production tables is exited.

func (*BaseRelationalParserListener) ExitTempSqlInvokedFunction

func (s *BaseRelationalParserListener) ExitTempSqlInvokedFunction(ctx *TempSqlInvokedFunctionContext)

ExitTempSqlInvokedFunction is called when production tempSqlInvokedFunction is exited.

func (*BaseRelationalParserListener) ExitTemplateClause

func (s *BaseRelationalParserListener) ExitTemplateClause(ctx *TemplateClauseContext)

ExitTemplateClause is called when production templateClause is exited.

func (*BaseRelationalParserListener) ExitTransactionLevel

func (s *BaseRelationalParserListener) ExitTransactionLevel(ctx *TransactionLevelContext)

ExitTransactionLevel is called when production transactionLevel is exited.

func (*BaseRelationalParserListener) ExitTransactionOption

func (s *BaseRelationalParserListener) ExitTransactionOption(ctx *TransactionOptionContext)

ExitTransactionOption is called when production transactionOption is exited.

func (*BaseRelationalParserListener) ExitTransactionStatement

func (s *BaseRelationalParserListener) ExitTransactionStatement(ctx *TransactionStatementContext)

ExitTransactionStatement is called when production transactionStatement is exited.

func (*BaseRelationalParserListener) ExitTraversalOrderClause

func (s *BaseRelationalParserListener) ExitTraversalOrderClause(ctx *TraversalOrderClauseContext)

ExitTraversalOrderClause is called when production traversalOrderClause is exited.

func (*BaseRelationalParserListener) ExitTrimFunctionCall

func (s *BaseRelationalParserListener) ExitTrimFunctionCall(ctx *TrimFunctionCallContext)

ExitTrimFunctionCall is called when production trimFunctionCall is exited.

func (*BaseRelationalParserListener) ExitUid

func (s *BaseRelationalParserListener) ExitUid(ctx *UidContext)

ExitUid is called when production uid is exited.

func (*BaseRelationalParserListener) ExitUidList

func (s *BaseRelationalParserListener) ExitUidList(ctx *UidListContext)

ExitUidList is called when production uidList is exited.

func (*BaseRelationalParserListener) ExitUidListWithNestings

func (s *BaseRelationalParserListener) ExitUidListWithNestings(ctx *UidListWithNestingsContext)

ExitUidListWithNestings is called when production uidListWithNestings is exited.

func (*BaseRelationalParserListener) ExitUidListWithNestingsInParens

func (s *BaseRelationalParserListener) ExitUidListWithNestingsInParens(ctx *UidListWithNestingsInParensContext)

ExitUidListWithNestingsInParens is called when production uidListWithNestingsInParens is exited.

func (*BaseRelationalParserListener) ExitUidWithNestings

func (s *BaseRelationalParserListener) ExitUidWithNestings(ctx *UidWithNestingsContext)

ExitUidWithNestings is called when production uidWithNestings is exited.

func (*BaseRelationalParserListener) ExitUnaryOperator

func (s *BaseRelationalParserListener) ExitUnaryOperator(ctx *UnaryOperatorContext)

ExitUnaryOperator is called when production unaryOperator is exited.

func (*BaseRelationalParserListener) ExitUpdateStatement

func (s *BaseRelationalParserListener) ExitUpdateStatement(ctx *UpdateStatementContext)

ExitUpdateStatement is called when production updateStatement is exited.

func (*BaseRelationalParserListener) ExitUpdatedElement

func (s *BaseRelationalParserListener) ExitUpdatedElement(ctx *UpdatedElementContext)

ExitUpdatedElement is called when production updatedElement is exited.

func (*BaseRelationalParserListener) ExitUserDefinedMacroFunctionStatementBody

func (s *BaseRelationalParserListener) ExitUserDefinedMacroFunctionStatementBody(ctx *UserDefinedMacroFunctionStatementBodyContext)

ExitUserDefinedMacroFunctionStatementBody is called when production userDefinedMacroFunctionStatementBody is exited.

func (*BaseRelationalParserListener) ExitUserDefinedScalarFunctionCall

func (s *BaseRelationalParserListener) ExitUserDefinedScalarFunctionCall(ctx *UserDefinedScalarFunctionCallContext)

ExitUserDefinedScalarFunctionCall is called when production userDefinedScalarFunctionCall is exited.

func (*BaseRelationalParserListener) ExitUserDefinedScalarFunctionName

func (s *BaseRelationalParserListener) ExitUserDefinedScalarFunctionName(ctx *UserDefinedScalarFunctionNameContext)

ExitUserDefinedScalarFunctionName is called when production userDefinedScalarFunctionName is exited.

func (*BaseRelationalParserListener) ExitUserVariables

func (s *BaseRelationalParserListener) ExitUserVariables(ctx *UserVariablesContext)

ExitUserVariables is called when production userVariables is exited.

func (*BaseRelationalParserListener) ExitUtilityStatement

func (s *BaseRelationalParserListener) ExitUtilityStatement(ctx *UtilityStatementContext)

ExitUtilityStatement is called when production utilityStatement is exited.

func (*BaseRelationalParserListener) ExitValuesFunctionCall

func (s *BaseRelationalParserListener) ExitValuesFunctionCall(ctx *ValuesFunctionCallContext)

ExitValuesFunctionCall is called when production valuesFunctionCall is exited.

func (*BaseRelationalParserListener) ExitVariableClause

func (s *BaseRelationalParserListener) ExitVariableClause(ctx *VariableClauseContext)

ExitVariableClause is called when production variableClause is exited.

func (*BaseRelationalParserListener) ExitVectorElementType

func (s *BaseRelationalParserListener) ExitVectorElementType(ctx *VectorElementTypeContext)

ExitVectorElementType is called when production vectorElementType is exited.

func (*BaseRelationalParserListener) ExitVectorEngine

func (s *BaseRelationalParserListener) ExitVectorEngine(ctx *VectorEngineContext)

ExitVectorEngine is called when production vectorEngine is exited.

func (*BaseRelationalParserListener) ExitVectorIndexDefinition

func (s *BaseRelationalParserListener) ExitVectorIndexDefinition(ctx *VectorIndexDefinitionContext)

ExitVectorIndexDefinition is called when production vectorIndexDefinition is exited.

func (*BaseRelationalParserListener) ExitVectorIndexOption

func (s *BaseRelationalParserListener) ExitVectorIndexOption(ctx *VectorIndexOptionContext)

ExitVectorIndexOption is called when production vectorIndexOption is exited.

func (*BaseRelationalParserListener) ExitVectorIndexOptionValue

func (s *BaseRelationalParserListener) ExitVectorIndexOptionValue(ctx *VectorIndexOptionValueContext)

ExitVectorIndexOptionValue is called when production vectorIndexOptionValue is exited.

func (*BaseRelationalParserListener) ExitVectorIndexOptions

func (s *BaseRelationalParserListener) ExitVectorIndexOptions(ctx *VectorIndexOptionsContext)

ExitVectorIndexOptions is called when production vectorIndexOptions is exited.

func (*BaseRelationalParserListener) ExitVectorType

func (s *BaseRelationalParserListener) ExitVectorType(ctx *VectorTypeContext)

ExitVectorType is called when production vectorType is exited.

func (*BaseRelationalParserListener) ExitViewDefinition

func (s *BaseRelationalParserListener) ExitViewDefinition(ctx *ViewDefinitionContext)

ExitViewDefinition is called when production viewDefinition is exited.

func (*BaseRelationalParserListener) ExitWeightFunctionCall

func (s *BaseRelationalParserListener) ExitWeightFunctionCall(ctx *WeightFunctionCallContext)

ExitWeightFunctionCall is called when production weightFunctionCall is exited.

func (*BaseRelationalParserListener) ExitWhereExpr

func (s *BaseRelationalParserListener) ExitWhereExpr(ctx *WhereExprContext)

ExitWhereExpr is called when production whereExpr is exited.

func (*BaseRelationalParserListener) ExitWindowName

func (s *BaseRelationalParserListener) ExitWindowName(ctx *WindowNameContext)

ExitWindowName is called when production windowName is exited.

func (*BaseRelationalParserListener) ExitWindowOption

func (s *BaseRelationalParserListener) ExitWindowOption(ctx *WindowOptionContext)

ExitWindowOption is called when production windowOption is exited.

func (*BaseRelationalParserListener) ExitWindowOptionsClause

func (s *BaseRelationalParserListener) ExitWindowOptionsClause(ctx *WindowOptionsClauseContext)

ExitWindowOptionsClause is called when production windowOptionsClause is exited.

func (*BaseRelationalParserListener) ExitWindowSpec

func (s *BaseRelationalParserListener) ExitWindowSpec(ctx *WindowSpecContext)

ExitWindowSpec is called when production windowSpec is exited.

func (*BaseRelationalParserListener) VisitErrorNode

func (s *BaseRelationalParserListener) VisitErrorNode(node antlr.ErrorNode)

VisitErrorNode is called when an error node is visited.

func (*BaseRelationalParserListener) VisitTerminal

func (s *BaseRelationalParserListener) VisitTerminal(node antlr.TerminalNode)

VisitTerminal is called when a terminal node is visited.

type BaseRelationalParserVisitor

type BaseRelationalParserVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BaseRelationalParserVisitor) VisitAdministrationStatement

func (v *BaseRelationalParserVisitor) VisitAdministrationStatement(ctx *AdministrationStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitAggregateFunctionCall

func (v *BaseRelationalParserVisitor) VisitAggregateFunctionCall(ctx *AggregateFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitAggregateLimitClause

func (v *BaseRelationalParserVisitor) VisitAggregateLimitClause(ctx *AggregateLimitClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitAggregateWindowedFunction

func (v *BaseRelationalParserVisitor) VisitAggregateWindowedFunction(ctx *AggregateWindowedFunctionContext) interface{}

func (*BaseRelationalParserVisitor) VisitArrayConstructor

func (v *BaseRelationalParserVisitor) VisitArrayConstructor(ctx *ArrayConstructorContext) interface{}

func (*BaseRelationalParserVisitor) VisitArrayConstructorExpressionAtom

func (v *BaseRelationalParserVisitor) VisitArrayConstructorExpressionAtom(ctx *ArrayConstructorExpressionAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitAssignmentField

func (v *BaseRelationalParserVisitor) VisitAssignmentField(ctx *AssignmentFieldContext) interface{}

func (*BaseRelationalParserVisitor) VisitAtomTableItem

func (v *BaseRelationalParserVisitor) VisitAtomTableItem(ctx *AtomTableItemContext) interface{}

func (*BaseRelationalParserVisitor) VisitBetweenComparisonPredicate

func (v *BaseRelationalParserVisitor) VisitBetweenComparisonPredicate(ctx *BetweenComparisonPredicateContext) interface{}

func (*BaseRelationalParserVisitor) VisitBinaryComparisonPredicate

func (v *BaseRelationalParserVisitor) VisitBinaryComparisonPredicate(ctx *BinaryComparisonPredicateContext) interface{}

func (*BaseRelationalParserVisitor) VisitBitExpressionAtom

func (v *BaseRelationalParserVisitor) VisitBitExpressionAtom(ctx *BitExpressionAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitBitOperator

func (v *BaseRelationalParserVisitor) VisitBitOperator(ctx *BitOperatorContext) interface{}

func (*BaseRelationalParserVisitor) VisitBitStringConstant

func (v *BaseRelationalParserVisitor) VisitBitStringConstant(ctx *BitStringConstantContext) interface{}

func (*BaseRelationalParserVisitor) VisitBooleanConstant

func (v *BaseRelationalParserVisitor) VisitBooleanConstant(ctx *BooleanConstantContext) interface{}

func (*BaseRelationalParserVisitor) VisitBooleanLiteral

func (v *BaseRelationalParserVisitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{}

func (*BaseRelationalParserVisitor) VisitBytesConstant

func (v *BaseRelationalParserVisitor) VisitBytesConstant(ctx *BytesConstantContext) interface{}

func (*BaseRelationalParserVisitor) VisitBytesLiteral

func (v *BaseRelationalParserVisitor) VisitBytesLiteral(ctx *BytesLiteralContext) interface{}

func (*BaseRelationalParserVisitor) VisitCaseExpressionFunctionCall

func (v *BaseRelationalParserVisitor) VisitCaseExpressionFunctionCall(ctx *CaseExpressionFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitCaseFuncAlternative

func (v *BaseRelationalParserVisitor) VisitCaseFuncAlternative(ctx *CaseFuncAlternativeContext) interface{}

func (*BaseRelationalParserVisitor) VisitCaseFunctionCall

func (v *BaseRelationalParserVisitor) VisitCaseFunctionCall(ctx *CaseFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitCharFunctionCall

func (v *BaseRelationalParserVisitor) VisitCharFunctionCall(ctx *CharFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitCharSet

func (v *BaseRelationalParserVisitor) VisitCharSet(ctx *CharSetContext) interface{}

func (*BaseRelationalParserVisitor) VisitCharsetName

func (v *BaseRelationalParserVisitor) VisitCharsetName(ctx *CharsetNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitCharsetNameBase

func (v *BaseRelationalParserVisitor) VisitCharsetNameBase(ctx *CharsetNameBaseContext) interface{}

func (*BaseRelationalParserVisitor) VisitCollationName

func (v *BaseRelationalParserVisitor) VisitCollationName(ctx *CollationNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitCollectionDataType

func (v *BaseRelationalParserVisitor) VisitCollectionDataType(ctx *CollectionDataTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitCollectionOptions

func (v *BaseRelationalParserVisitor) VisitCollectionOptions(ctx *CollectionOptionsContext) interface{}

func (*BaseRelationalParserVisitor) VisitColumnDefinition

func (v *BaseRelationalParserVisitor) VisitColumnDefinition(ctx *ColumnDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitColumnType

func (v *BaseRelationalParserVisitor) VisitColumnType(ctx *ColumnTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitCommitStatement

func (v *BaseRelationalParserVisitor) VisitCommitStatement(ctx *CommitStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitComparisonOperator

func (v *BaseRelationalParserVisitor) VisitComparisonOperator(ctx *ComparisonOperatorContext) interface{}

func (*BaseRelationalParserVisitor) VisitConstantExpressionAtom

func (v *BaseRelationalParserVisitor) VisitConstantExpressionAtom(ctx *ConstantExpressionAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitContinuationAtom

func (v *BaseRelationalParserVisitor) VisitContinuationAtom(ctx *ContinuationAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitConvertedDataType

func (v *BaseRelationalParserVisitor) VisitConvertedDataType(ctx *ConvertedDataTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitCopyExportStatement

func (v *BaseRelationalParserVisitor) VisitCopyExportStatement(ctx *CopyExportStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitCopyImportStatement

func (v *BaseRelationalParserVisitor) VisitCopyImportStatement(ctx *CopyImportStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitCreateDatabaseStatement

func (v *BaseRelationalParserVisitor) VisitCreateDatabaseStatement(ctx *CreateDatabaseStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitCreateSchemaStatement

func (v *BaseRelationalParserVisitor) VisitCreateSchemaStatement(ctx *CreateSchemaStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitCreateSchemaTemplateStatement

func (v *BaseRelationalParserVisitor) VisitCreateSchemaTemplateStatement(ctx *CreateSchemaTemplateStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitCreateTempFunction

func (v *BaseRelationalParserVisitor) VisitCreateTempFunction(ctx *CreateTempFunctionContext) interface{}

func (*BaseRelationalParserVisitor) VisitCtes

func (v *BaseRelationalParserVisitor) VisitCtes(ctx *CtesContext) interface{}

func (*BaseRelationalParserVisitor) VisitCurrentTimestamp

func (v *BaseRelationalParserVisitor) VisitCurrentTimestamp(ctx *CurrentTimestampContext) interface{}

func (*BaseRelationalParserVisitor) VisitDataTypeFunctionCall

func (v *BaseRelationalParserVisitor) VisitDataTypeFunctionCall(ctx *DataTypeFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitDdlStatement

func (v *BaseRelationalParserVisitor) VisitDdlStatement(ctx *DdlStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitDecimalConstant

func (v *BaseRelationalParserVisitor) VisitDecimalConstant(ctx *DecimalConstantContext) interface{}

func (*BaseRelationalParserVisitor) VisitDecimalLiteral

func (v *BaseRelationalParserVisitor) VisitDecimalLiteral(ctx *DecimalLiteralContext) interface{}

func (*BaseRelationalParserVisitor) VisitDeclareBlock

func (v *BaseRelationalParserVisitor) VisitDeclareBlock(ctx *DeclareBlockContext) interface{}

func (*BaseRelationalParserVisitor) VisitDeclaredFunction

func (v *BaseRelationalParserVisitor) VisitDeclaredFunction(ctx *DeclaredFunctionContext) interface{}

func (*BaseRelationalParserVisitor) VisitDefaultValue

func (v *BaseRelationalParserVisitor) VisitDefaultValue(ctx *DefaultValueContext) interface{}

func (*BaseRelationalParserVisitor) VisitDeleteStatement

func (v *BaseRelationalParserVisitor) VisitDeleteStatement(ctx *DeleteStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitDescribeConnection

func (v *BaseRelationalParserVisitor) VisitDescribeConnection(ctx *DescribeConnectionContext) interface{}

func (*BaseRelationalParserVisitor) VisitDescribeStatements

func (v *BaseRelationalParserVisitor) VisitDescribeStatements(ctx *DescribeStatementsContext) interface{}

func (*BaseRelationalParserVisitor) VisitDeterministicCharacteristic

func (v *BaseRelationalParserVisitor) VisitDeterministicCharacteristic(ctx *DeterministicCharacteristicContext) interface{}

func (*BaseRelationalParserVisitor) VisitDimensionDataType

func (v *BaseRelationalParserVisitor) VisitDimensionDataType(ctx *DimensionDataTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitDispatchClause

func (v *BaseRelationalParserVisitor) VisitDispatchClause(ctx *DispatchClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitDmlStatement

func (v *BaseRelationalParserVisitor) VisitDmlStatement(ctx *DmlStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitDropDatabaseStatement

func (v *BaseRelationalParserVisitor) VisitDropDatabaseStatement(ctx *DropDatabaseStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitDropSchemaStatement

func (v *BaseRelationalParserVisitor) VisitDropSchemaStatement(ctx *DropSchemaStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitDropSchemaTemplateStatement

func (v *BaseRelationalParserVisitor) VisitDropSchemaTemplateStatement(ctx *DropSchemaTemplateStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitDropTempFunction

func (v *BaseRelationalParserVisitor) VisitDropTempFunction(ctx *DropTempFunctionContext) interface{}

func (*BaseRelationalParserVisitor) VisitEnumDefinition

func (v *BaseRelationalParserVisitor) VisitEnumDefinition(ctx *EnumDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitExecuteContinuationStatement

func (v *BaseRelationalParserVisitor) VisitExecuteContinuationStatement(ctx *ExecuteContinuationStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitExecuteStatement

func (v *BaseRelationalParserVisitor) VisitExecuteStatement(ctx *ExecuteStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitExistsExpressionAtom

func (v *BaseRelationalParserVisitor) VisitExistsExpressionAtom(ctx *ExistsExpressionAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitExpressionOrDefault

func (v *BaseRelationalParserVisitor) VisitExpressionOrDefault(ctx *ExpressionOrDefaultContext) interface{}

func (*BaseRelationalParserVisitor) VisitExpressionWithOptionalName

func (v *BaseRelationalParserVisitor) VisitExpressionWithOptionalName(ctx *ExpressionWithOptionalNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitExpressions

func (v *BaseRelationalParserVisitor) VisitExpressions(ctx *ExpressionsContext) interface{}

func (*BaseRelationalParserVisitor) VisitExpressionsWithDefaults

func (v *BaseRelationalParserVisitor) VisitExpressionsWithDefaults(ctx *ExpressionsWithDefaultsContext) interface{}

func (*BaseRelationalParserVisitor) VisitExtractFunctionCall

func (v *BaseRelationalParserVisitor) VisitExtractFunctionCall(ctx *ExtractFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitFromClause

func (v *BaseRelationalParserVisitor) VisitFromClause(ctx *FromClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitFullColumnName

func (v *BaseRelationalParserVisitor) VisitFullColumnName(ctx *FullColumnNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitFullColumnNameExpressionAtom

func (v *BaseRelationalParserVisitor) VisitFullColumnNameExpressionAtom(ctx *FullColumnNameExpressionAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitFullDescribeStatement

func (v *BaseRelationalParserVisitor) VisitFullDescribeStatement(ctx *FullDescribeStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitFullId

func (v *BaseRelationalParserVisitor) VisitFullId(ctx *FullIdContext) interface{}

func (*BaseRelationalParserVisitor) VisitFullIdList

func (v *BaseRelationalParserVisitor) VisitFullIdList(ctx *FullIdListContext) interface{}

func (*BaseRelationalParserVisitor) VisitFunctionArg

func (v *BaseRelationalParserVisitor) VisitFunctionArg(ctx *FunctionArgContext) interface{}

func (*BaseRelationalParserVisitor) VisitFunctionArgs

func (v *BaseRelationalParserVisitor) VisitFunctionArgs(ctx *FunctionArgsContext) interface{}

func (*BaseRelationalParserVisitor) VisitFunctionCallExpressionAtom

func (v *BaseRelationalParserVisitor) VisitFunctionCallExpressionAtom(ctx *FunctionCallExpressionAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitFunctionColumnType

func (v *BaseRelationalParserVisitor) VisitFunctionColumnType(ctx *FunctionColumnTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitFunctionNameBase

func (v *BaseRelationalParserVisitor) VisitFunctionNameBase(ctx *FunctionNameBaseContext) interface{}

func (*BaseRelationalParserVisitor) VisitFunctionNameKeyword

func (v *BaseRelationalParserVisitor) VisitFunctionNameKeyword(ctx *FunctionNameKeywordContext) interface{}

func (*BaseRelationalParserVisitor) VisitFunctionSpecification

func (v *BaseRelationalParserVisitor) VisitFunctionSpecification(ctx *FunctionSpecificationContext) interface{}

func (*BaseRelationalParserVisitor) VisitGetFormatFunctionCall

func (v *BaseRelationalParserVisitor) VisitGetFormatFunctionCall(ctx *GetFormatFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitGroupByClause

func (v *BaseRelationalParserVisitor) VisitGroupByClause(ctx *GroupByClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitGroupByItem

func (v *BaseRelationalParserVisitor) VisitGroupByItem(ctx *GroupByItemContext) interface{}

func (*BaseRelationalParserVisitor) VisitHavingClause

func (v *BaseRelationalParserVisitor) VisitHavingClause(ctx *HavingClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitHelpStatement

func (v *BaseRelationalParserVisitor) VisitHelpStatement(ctx *HelpStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitHnswMetric

func (v *BaseRelationalParserVisitor) VisitHnswMetric(ctx *HnswMetricContext) interface{}

func (*BaseRelationalParserVisitor) VisitIfExists

func (v *BaseRelationalParserVisitor) VisitIfExists(ctx *IfExistsContext) interface{}

func (*BaseRelationalParserVisitor) VisitIfNotExists

func (v *BaseRelationalParserVisitor) VisitIfNotExists(ctx *IfNotExistsContext) interface{}

func (*BaseRelationalParserVisitor) VisitInList

func (v *BaseRelationalParserVisitor) VisitInList(ctx *InListContext) interface{}

func (*BaseRelationalParserVisitor) VisitInPredicate

func (v *BaseRelationalParserVisitor) VisitInPredicate(ctx *InPredicateContext) interface{}

func (*BaseRelationalParserVisitor) VisitIncludeClause

func (v *BaseRelationalParserVisitor) VisitIncludeClause(ctx *IncludeClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexAsSelectDefinition

func (v *BaseRelationalParserVisitor) VisitIndexAsSelectDefinition(ctx *IndexAsSelectDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexAttribute

func (v *BaseRelationalParserVisitor) VisitIndexAttribute(ctx *IndexAttributeContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexAttributes

func (v *BaseRelationalParserVisitor) VisitIndexAttributes(ctx *IndexAttributesContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexColumnList

func (v *BaseRelationalParserVisitor) VisitIndexColumnList(ctx *IndexColumnListContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexColumnName

func (v *BaseRelationalParserVisitor) VisitIndexColumnName(ctx *IndexColumnNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexColumnNames

func (v *BaseRelationalParserVisitor) VisitIndexColumnNames(ctx *IndexColumnNamesContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexColumnSpec

func (v *BaseRelationalParserVisitor) VisitIndexColumnSpec(ctx *IndexColumnSpecContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexHint

func (v *BaseRelationalParserVisitor) VisitIndexHint(ctx *IndexHintContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexHintType

func (v *BaseRelationalParserVisitor) VisitIndexHintType(ctx *IndexHintTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexOnSourceDefinition

func (v *BaseRelationalParserVisitor) VisitIndexOnSourceDefinition(ctx *IndexOnSourceDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexOption

func (v *BaseRelationalParserVisitor) VisitIndexOption(ctx *IndexOptionContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexOptions

func (v *BaseRelationalParserVisitor) VisitIndexOptions(ctx *IndexOptionsContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexPartitionClause

func (v *BaseRelationalParserVisitor) VisitIndexPartitionClause(ctx *IndexPartitionClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitIndexType

func (v *BaseRelationalParserVisitor) VisitIndexType(ctx *IndexTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitInlineTableDefinition

func (v *BaseRelationalParserVisitor) VisitInlineTableDefinition(ctx *InlineTableDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitInlineTableItem

func (v *BaseRelationalParserVisitor) VisitInlineTableItem(ctx *InlineTableItemContext) interface{}

func (*BaseRelationalParserVisitor) VisitInnerJoin

func (v *BaseRelationalParserVisitor) VisitInnerJoin(ctx *InnerJoinContext) interface{}

func (*BaseRelationalParserVisitor) VisitInsertStatement

func (v *BaseRelationalParserVisitor) VisitInsertStatement(ctx *InsertStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitInsertStatementValueSelect

func (v *BaseRelationalParserVisitor) VisitInsertStatementValueSelect(ctx *InsertStatementValueSelectContext) interface{}

func (*BaseRelationalParserVisitor) VisitInsertStatementValueValues

func (v *BaseRelationalParserVisitor) VisitInsertStatementValueValues(ctx *InsertStatementValueValuesContext) interface{}

func (*BaseRelationalParserVisitor) VisitIntervalType

func (v *BaseRelationalParserVisitor) VisitIntervalType(ctx *IntervalTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitIntervalTypeBase

func (v *BaseRelationalParserVisitor) VisitIntervalTypeBase(ctx *IntervalTypeBaseContext) interface{}

func (*BaseRelationalParserVisitor) VisitIsExpression

func (v *BaseRelationalParserVisitor) VisitIsExpression(ctx *IsExpressionContext) interface{}

func (*BaseRelationalParserVisitor) VisitJsonOperator

func (v *BaseRelationalParserVisitor) VisitJsonOperator(ctx *JsonOperatorContext) interface{}

func (*BaseRelationalParserVisitor) VisitKeywordsCanBeId

func (v *BaseRelationalParserVisitor) VisitKeywordsCanBeId(ctx *KeywordsCanBeIdContext) interface{}

func (*BaseRelationalParserVisitor) VisitKillStatement

func (v *BaseRelationalParserVisitor) VisitKillStatement(ctx *KillStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitLanguageClause

func (v *BaseRelationalParserVisitor) VisitLanguageClause(ctx *LanguageClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitLanguageName

func (v *BaseRelationalParserVisitor) VisitLanguageName(ctx *LanguageNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitLengthOneDimension

func (v *BaseRelationalParserVisitor) VisitLengthOneDimension(ctx *LengthOneDimensionContext) interface{}

func (*BaseRelationalParserVisitor) VisitLengthTwoDimension

func (v *BaseRelationalParserVisitor) VisitLengthTwoDimension(ctx *LengthTwoDimensionContext) interface{}

func (*BaseRelationalParserVisitor) VisitLengthTwoOptionalDimension

func (v *BaseRelationalParserVisitor) VisitLengthTwoOptionalDimension(ctx *LengthTwoOptionalDimensionContext) interface{}

func (*BaseRelationalParserVisitor) VisitLevelInWeightListElement

func (v *BaseRelationalParserVisitor) VisitLevelInWeightListElement(ctx *LevelInWeightListElementContext) interface{}

func (*BaseRelationalParserVisitor) VisitLevelWeightList

func (v *BaseRelationalParserVisitor) VisitLevelWeightList(ctx *LevelWeightListContext) interface{}

func (*BaseRelationalParserVisitor) VisitLevelWeightRange

func (v *BaseRelationalParserVisitor) VisitLevelWeightRange(ctx *LevelWeightRangeContext) interface{}

func (*BaseRelationalParserVisitor) VisitLikePredicate

func (v *BaseRelationalParserVisitor) VisitLikePredicate(ctx *LikePredicateContext) interface{}

func (*BaseRelationalParserVisitor) VisitLimitClause

func (v *BaseRelationalParserVisitor) VisitLimitClause(ctx *LimitClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitLimitClauseAtom

func (v *BaseRelationalParserVisitor) VisitLimitClauseAtom(ctx *LimitClauseAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitLoadedTableIndexes

func (v *BaseRelationalParserVisitor) VisitLoadedTableIndexes(ctx *LoadedTableIndexesContext) interface{}

func (*BaseRelationalParserVisitor) VisitLogicalExpression

func (v *BaseRelationalParserVisitor) VisitLogicalExpression(ctx *LogicalExpressionContext) interface{}

func (*BaseRelationalParserVisitor) VisitLogicalOperator

func (v *BaseRelationalParserVisitor) VisitLogicalOperator(ctx *LogicalOperatorContext) interface{}

func (*BaseRelationalParserVisitor) VisitLongVarbinaryDataType

func (v *BaseRelationalParserVisitor) VisitLongVarbinaryDataType(ctx *LongVarbinaryDataTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitLongVarcharDataType

func (v *BaseRelationalParserVisitor) VisitLongVarcharDataType(ctx *LongVarcharDataTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitMathExpressionAtom

func (v *BaseRelationalParserVisitor) VisitMathExpressionAtom(ctx *MathExpressionAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitMathOperator

func (v *BaseRelationalParserVisitor) VisitMathOperator(ctx *MathOperatorContext) interface{}

func (*BaseRelationalParserVisitor) VisitNamedFunctionArg

func (v *BaseRelationalParserVisitor) VisitNamedFunctionArg(ctx *NamedFunctionArgContext) interface{}

func (*BaseRelationalParserVisitor) VisitNamedOrUnnamedFunctionArgs

func (v *BaseRelationalParserVisitor) VisitNamedOrUnnamedFunctionArgs(ctx *NamedOrUnnamedFunctionArgsContext) interface{}

func (*BaseRelationalParserVisitor) VisitNamedQuery

func (v *BaseRelationalParserVisitor) VisitNamedQuery(ctx *NamedQueryContext) interface{}

func (*BaseRelationalParserVisitor) VisitNationalStringDataType

func (v *BaseRelationalParserVisitor) VisitNationalStringDataType(ctx *NationalStringDataTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitNationalVaryingStringDataType

func (v *BaseRelationalParserVisitor) VisitNationalVaryingStringDataType(ctx *NationalVaryingStringDataTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitNaturalJoin

func (v *BaseRelationalParserVisitor) VisitNaturalJoin(ctx *NaturalJoinContext) interface{}

func (*BaseRelationalParserVisitor) VisitNegativeDecimalConstant

func (v *BaseRelationalParserVisitor) VisitNegativeDecimalConstant(ctx *NegativeDecimalConstantContext) interface{}

func (*BaseRelationalParserVisitor) VisitNonAggregateFunctionCall

func (v *BaseRelationalParserVisitor) VisitNonAggregateFunctionCall(ctx *NonAggregateFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitNonAggregateWindowedFunction

func (v *BaseRelationalParserVisitor) VisitNonAggregateWindowedFunction(ctx *NonAggregateWindowedFunctionContext) interface{}

func (*BaseRelationalParserVisitor) VisitNotExpression

func (v *BaseRelationalParserVisitor) VisitNotExpression(ctx *NotExpressionContext) interface{}

func (*BaseRelationalParserVisitor) VisitNullCallClause

func (v *BaseRelationalParserVisitor) VisitNullCallClause(ctx *NullCallClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitNullColumnConstraint

func (v *BaseRelationalParserVisitor) VisitNullColumnConstraint(ctx *NullColumnConstraintContext) interface{}

func (*BaseRelationalParserVisitor) VisitNullConstant

func (v *BaseRelationalParserVisitor) VisitNullConstant(ctx *NullConstantContext) interface{}

func (*BaseRelationalParserVisitor) VisitNullLiteral

func (v *BaseRelationalParserVisitor) VisitNullLiteral(ctx *NullLiteralContext) interface{}

func (*BaseRelationalParserVisitor) VisitNullNotnull

func (v *BaseRelationalParserVisitor) VisitNullNotnull(ctx *NullNotnullContext) interface{}

func (*BaseRelationalParserVisitor) VisitNullTreatmentClause

func (v *BaseRelationalParserVisitor) VisitNullTreatmentClause(ctx *NullTreatmentClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitOfTypeClause

func (v *BaseRelationalParserVisitor) VisitOfTypeClause(ctx *OfTypeClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitOption

func (v *BaseRelationalParserVisitor) VisitOption(ctx *OptionContext) interface{}

func (*BaseRelationalParserVisitor) VisitOptionsClause

func (v *BaseRelationalParserVisitor) VisitOptionsClause(ctx *OptionsClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitOrderByClause

func (v *BaseRelationalParserVisitor) VisitOrderByClause(ctx *OrderByClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitOrderByExpression

func (v *BaseRelationalParserVisitor) VisitOrderByExpression(ctx *OrderByExpressionContext) interface{}

func (*BaseRelationalParserVisitor) VisitOrderClause

func (v *BaseRelationalParserVisitor) VisitOrderClause(ctx *OrderClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitOuterJoin

func (v *BaseRelationalParserVisitor) VisitOuterJoin(ctx *OuterJoinContext) interface{}

func (*BaseRelationalParserVisitor) VisitOverClause

func (v *BaseRelationalParserVisitor) VisitOverClause(ctx *OverClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitParameterMode

func (v *BaseRelationalParserVisitor) VisitParameterMode(ctx *ParameterModeContext) interface{}

func (*BaseRelationalParserVisitor) VisitParameterStyle

func (v *BaseRelationalParserVisitor) VisitParameterStyle(ctx *ParameterStyleContext) interface{}

func (*BaseRelationalParserVisitor) VisitParenthesisQuery

func (v *BaseRelationalParserVisitor) VisitParenthesisQuery(ctx *ParenthesisQueryContext) interface{}

func (*BaseRelationalParserVisitor) VisitPartitionClause

func (v *BaseRelationalParserVisitor) VisitPartitionClause(ctx *PartitionClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitPath

func (v *BaseRelationalParserVisitor) VisitPath(ctx *PathContext) interface{}

func (*BaseRelationalParserVisitor) VisitPositionFunctionCall

func (v *BaseRelationalParserVisitor) VisitPositionFunctionCall(ctx *PositionFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitPredicatedExpression

func (v *BaseRelationalParserVisitor) VisitPredicatedExpression(ctx *PredicatedExpressionContext) interface{}

func (*BaseRelationalParserVisitor) VisitPrepareStatement

func (v *BaseRelationalParserVisitor) VisitPrepareStatement(ctx *PrepareStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitPreparedStatement

func (v *BaseRelationalParserVisitor) VisitPreparedStatement(ctx *PreparedStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitPreparedStatementParameter

func (v *BaseRelationalParserVisitor) VisitPreparedStatementParameter(ctx *PreparedStatementParameterContext) interface{}

func (*BaseRelationalParserVisitor) VisitPreparedStatementParameterAtom

func (v *BaseRelationalParserVisitor) VisitPreparedStatementParameterAtom(ctx *PreparedStatementParameterAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitPrimaryKeyDefinition

func (v *BaseRelationalParserVisitor) VisitPrimaryKeyDefinition(ctx *PrimaryKeyDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitPrimitiveType

func (v *BaseRelationalParserVisitor) VisitPrimitiveType(ctx *PrimitiveTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitQualifyClause

func (v *BaseRelationalParserVisitor) VisitQualifyClause(ctx *QualifyClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitQuery

func (v *BaseRelationalParserVisitor) VisitQuery(ctx *QueryContext) interface{}

func (*BaseRelationalParserVisitor) VisitQueryTermDefault

func (v *BaseRelationalParserVisitor) VisitQueryTermDefault(ctx *QueryTermDefaultContext) interface{}

func (*BaseRelationalParserVisitor) VisitRecordConstructor

func (v *BaseRelationalParserVisitor) VisitRecordConstructor(ctx *RecordConstructorContext) interface{}

func (*BaseRelationalParserVisitor) VisitRecordConstructorExpressionAtom

func (v *BaseRelationalParserVisitor) VisitRecordConstructorExpressionAtom(ctx *RecordConstructorExpressionAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitRecordConstructorForInlineTable

func (v *BaseRelationalParserVisitor) VisitRecordConstructorForInlineTable(ctx *RecordConstructorForInlineTableContext) interface{}

func (*BaseRelationalParserVisitor) VisitRecordConstructorForInsert

func (v *BaseRelationalParserVisitor) VisitRecordConstructorForInsert(ctx *RecordConstructorForInsertContext) interface{}

func (*BaseRelationalParserVisitor) VisitResetStatement

func (v *BaseRelationalParserVisitor) VisitResetStatement(ctx *ResetStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitReturnsClause

func (v *BaseRelationalParserVisitor) VisitReturnsClause(ctx *ReturnsClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitReturnsTableType

func (v *BaseRelationalParserVisitor) VisitReturnsTableType(ctx *ReturnsTableTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitReturnsType

func (v *BaseRelationalParserVisitor) VisitReturnsType(ctx *ReturnsTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitRollbackStatement

func (v *BaseRelationalParserVisitor) VisitRollbackStatement(ctx *RollbackStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitRoot

func (v *BaseRelationalParserVisitor) VisitRoot(ctx *RootContext) interface{}

func (*BaseRelationalParserVisitor) VisitRoutineCharacteristics

func (v *BaseRelationalParserVisitor) VisitRoutineCharacteristics(ctx *RoutineCharacteristicsContext) interface{}

func (*BaseRelationalParserVisitor) VisitScalarFunctionCall

func (v *BaseRelationalParserVisitor) VisitScalarFunctionCall(ctx *ScalarFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitScalarFunctionName

func (v *BaseRelationalParserVisitor) VisitScalarFunctionName(ctx *ScalarFunctionNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitSchemaId

func (v *BaseRelationalParserVisitor) VisitSchemaId(ctx *SchemaIdContext) interface{}

func (*BaseRelationalParserVisitor) VisitSchemaTemplateId

func (v *BaseRelationalParserVisitor) VisitSchemaTemplateId(ctx *SchemaTemplateIdContext) interface{}

func (*BaseRelationalParserVisitor) VisitSelectElements

func (v *BaseRelationalParserVisitor) VisitSelectElements(ctx *SelectElementsContext) interface{}

func (*BaseRelationalParserVisitor) VisitSelectExpressionElement

func (v *BaseRelationalParserVisitor) VisitSelectExpressionElement(ctx *SelectExpressionElementContext) interface{}

func (*BaseRelationalParserVisitor) VisitSelectQualifierStarElement

func (v *BaseRelationalParserVisitor) VisitSelectQualifierStarElement(ctx *SelectQualifierStarElementContext) interface{}

func (*BaseRelationalParserVisitor) VisitSelectStarElement

func (v *BaseRelationalParserVisitor) VisitSelectStarElement(ctx *SelectStarElementContext) interface{}

func (*BaseRelationalParserVisitor) VisitSelectStatement

func (v *BaseRelationalParserVisitor) VisitSelectStatement(ctx *SelectStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitSetAutocommit

func (v *BaseRelationalParserVisitor) VisitSetAutocommit(ctx *SetAutocommitContext) interface{}

func (*BaseRelationalParserVisitor) VisitSetAutocommitStatement

func (v *BaseRelationalParserVisitor) VisitSetAutocommitStatement(ctx *SetAutocommitStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitSetCharset

func (v *BaseRelationalParserVisitor) VisitSetCharset(ctx *SetCharsetContext) interface{}

func (*BaseRelationalParserVisitor) VisitSetNames

func (v *BaseRelationalParserVisitor) VisitSetNames(ctx *SetNamesContext) interface{}

func (*BaseRelationalParserVisitor) VisitSetNewValueInsideTrigger

func (v *BaseRelationalParserVisitor) VisitSetNewValueInsideTrigger(ctx *SetNewValueInsideTriggerContext) interface{}

func (*BaseRelationalParserVisitor) VisitSetQuery

func (v *BaseRelationalParserVisitor) VisitSetQuery(ctx *SetQueryContext) interface{}

func (*BaseRelationalParserVisitor) VisitSetTransaction

func (v *BaseRelationalParserVisitor) VisitSetTransaction(ctx *SetTransactionContext) interface{}

func (*BaseRelationalParserVisitor) VisitSetTransactionStatement

func (v *BaseRelationalParserVisitor) VisitSetTransactionStatement(ctx *SetTransactionStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitSetVariable

func (v *BaseRelationalParserVisitor) VisitSetVariable(ctx *SetVariableContext) interface{}

func (*BaseRelationalParserVisitor) VisitShowDatabasesStatement

func (v *BaseRelationalParserVisitor) VisitShowDatabasesStatement(ctx *ShowDatabasesStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitShowSchemaTemplatesStatement

func (v *BaseRelationalParserVisitor) VisitShowSchemaTemplatesStatement(ctx *ShowSchemaTemplatesStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitSimpleDataType

func (v *BaseRelationalParserVisitor) VisitSimpleDataType(ctx *SimpleDataTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitSimpleDescribeSchemaStatement

func (v *BaseRelationalParserVisitor) VisitSimpleDescribeSchemaStatement(ctx *SimpleDescribeSchemaStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitSimpleDescribeSchemaTemplateStatement

func (v *BaseRelationalParserVisitor) VisitSimpleDescribeSchemaTemplateStatement(ctx *SimpleDescribeSchemaTemplateStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitSimpleFunctionCall

func (v *BaseRelationalParserVisitor) VisitSimpleFunctionCall(ctx *SimpleFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitSimpleId

func (v *BaseRelationalParserVisitor) VisitSimpleId(ctx *SimpleIdContext) interface{}

func (*BaseRelationalParserVisitor) VisitSimpleTable

func (v *BaseRelationalParserVisitor) VisitSimpleTable(ctx *SimpleTableContext) interface{}

func (*BaseRelationalParserVisitor) VisitSpatialDataType

func (v *BaseRelationalParserVisitor) VisitSpatialDataType(ctx *SpatialDataTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitSpecificFunctionCall

func (v *BaseRelationalParserVisitor) VisitSpecificFunctionCall(ctx *SpecificFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitSqlInvokedFunction

func (v *BaseRelationalParserVisitor) VisitSqlInvokedFunction(ctx *SqlInvokedFunctionContext) interface{}

func (*BaseRelationalParserVisitor) VisitSqlParameterDeclaration

func (v *BaseRelationalParserVisitor) VisitSqlParameterDeclaration(ctx *SqlParameterDeclarationContext) interface{}

func (*BaseRelationalParserVisitor) VisitSqlParameterDeclarationList

func (v *BaseRelationalParserVisitor) VisitSqlParameterDeclarationList(ctx *SqlParameterDeclarationListContext) interface{}

func (*BaseRelationalParserVisitor) VisitSqlParameterDeclarations

func (v *BaseRelationalParserVisitor) VisitSqlParameterDeclarations(ctx *SqlParameterDeclarationsContext) interface{}

func (*BaseRelationalParserVisitor) VisitStartTransaction

func (v *BaseRelationalParserVisitor) VisitStartTransaction(ctx *StartTransactionContext) interface{}

func (*BaseRelationalParserVisitor) VisitStatement

func (v *BaseRelationalParserVisitor) VisitStatement(ctx *StatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitStatementBody

func (v *BaseRelationalParserVisitor) VisitStatementBody(ctx *StatementBodyContext) interface{}

func (*BaseRelationalParserVisitor) VisitStatementOption

func (v *BaseRelationalParserVisitor) VisitStatementOption(ctx *StatementOptionContext) interface{}

func (*BaseRelationalParserVisitor) VisitStatementOptions

func (v *BaseRelationalParserVisitor) VisitStatementOptions(ctx *StatementOptionsContext) interface{}

func (*BaseRelationalParserVisitor) VisitStatements

func (v *BaseRelationalParserVisitor) VisitStatements(ctx *StatementsContext) interface{}

func (*BaseRelationalParserVisitor) VisitStoredQueryDefinition

func (v *BaseRelationalParserVisitor) VisitStoredQueryDefinition(ctx *StoredQueryDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitStraightJoin

func (v *BaseRelationalParserVisitor) VisitStraightJoin(ctx *StraightJoinContext) interface{}

func (*BaseRelationalParserVisitor) VisitStringConstant

func (v *BaseRelationalParserVisitor) VisitStringConstant(ctx *StringConstantContext) interface{}

func (*BaseRelationalParserVisitor) VisitStringDataType

func (v *BaseRelationalParserVisitor) VisitStringDataType(ctx *StringDataTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitStringLiteral

func (v *BaseRelationalParserVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{}

func (*BaseRelationalParserVisitor) VisitStructDefinition

func (v *BaseRelationalParserVisitor) VisitStructDefinition(ctx *StructDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitSubqueryExpressionAtom

func (v *BaseRelationalParserVisitor) VisitSubqueryExpressionAtom(ctx *SubqueryExpressionAtomContext) interface{}

func (*BaseRelationalParserVisitor) VisitSubqueryTableItem

func (v *BaseRelationalParserVisitor) VisitSubqueryTableItem(ctx *SubqueryTableItemContext) interface{}

func (*BaseRelationalParserVisitor) VisitSubscriptExpression

func (v *BaseRelationalParserVisitor) VisitSubscriptExpression(ctx *SubscriptExpressionContext) interface{}

func (*BaseRelationalParserVisitor) VisitSubstrFunctionCall

func (v *BaseRelationalParserVisitor) VisitSubstrFunctionCall(ctx *SubstrFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitTableDefinition

func (v *BaseRelationalParserVisitor) VisitTableDefinition(ctx *TableDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitTableFunction

func (v *BaseRelationalParserVisitor) VisitTableFunction(ctx *TableFunctionContext) interface{}

func (*BaseRelationalParserVisitor) VisitTableFunctionColumnList

func (v *BaseRelationalParserVisitor) VisitTableFunctionColumnList(ctx *TableFunctionColumnListContext) interface{}

func (*BaseRelationalParserVisitor) VisitTableFunctionColumnListElement

func (v *BaseRelationalParserVisitor) VisitTableFunctionColumnListElement(ctx *TableFunctionColumnListElementContext) interface{}

func (*BaseRelationalParserVisitor) VisitTableFunctionName

func (v *BaseRelationalParserVisitor) VisitTableFunctionName(ctx *TableFunctionNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitTableIndexes

func (v *BaseRelationalParserVisitor) VisitTableIndexes(ctx *TableIndexesContext) interface{}

func (*BaseRelationalParserVisitor) VisitTableName

func (v *BaseRelationalParserVisitor) VisitTableName(ctx *TableNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitTableSourceBase

func (v *BaseRelationalParserVisitor) VisitTableSourceBase(ctx *TableSourceBaseContext) interface{}

func (*BaseRelationalParserVisitor) VisitTableSources

func (v *BaseRelationalParserVisitor) VisitTableSources(ctx *TableSourcesContext) interface{}

func (*BaseRelationalParserVisitor) VisitTableValuedFunction

func (v *BaseRelationalParserVisitor) VisitTableValuedFunction(ctx *TableValuedFunctionContext) interface{}

func (*BaseRelationalParserVisitor) VisitTables

func (v *BaseRelationalParserVisitor) VisitTables(ctx *TablesContext) interface{}

func (*BaseRelationalParserVisitor) VisitTempSqlInvokedFunction

func (v *BaseRelationalParserVisitor) VisitTempSqlInvokedFunction(ctx *TempSqlInvokedFunctionContext) interface{}

func (*BaseRelationalParserVisitor) VisitTemplateClause

func (v *BaseRelationalParserVisitor) VisitTemplateClause(ctx *TemplateClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitTransactionLevel

func (v *BaseRelationalParserVisitor) VisitTransactionLevel(ctx *TransactionLevelContext) interface{}

func (*BaseRelationalParserVisitor) VisitTransactionOption

func (v *BaseRelationalParserVisitor) VisitTransactionOption(ctx *TransactionOptionContext) interface{}

func (*BaseRelationalParserVisitor) VisitTransactionStatement

func (v *BaseRelationalParserVisitor) VisitTransactionStatement(ctx *TransactionStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitTraversalOrderClause

func (v *BaseRelationalParserVisitor) VisitTraversalOrderClause(ctx *TraversalOrderClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitTrimFunctionCall

func (v *BaseRelationalParserVisitor) VisitTrimFunctionCall(ctx *TrimFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitUid

func (v *BaseRelationalParserVisitor) VisitUid(ctx *UidContext) interface{}

func (*BaseRelationalParserVisitor) VisitUidList

func (v *BaseRelationalParserVisitor) VisitUidList(ctx *UidListContext) interface{}

func (*BaseRelationalParserVisitor) VisitUidListWithNestings

func (v *BaseRelationalParserVisitor) VisitUidListWithNestings(ctx *UidListWithNestingsContext) interface{}

func (*BaseRelationalParserVisitor) VisitUidListWithNestingsInParens

func (v *BaseRelationalParserVisitor) VisitUidListWithNestingsInParens(ctx *UidListWithNestingsInParensContext) interface{}

func (*BaseRelationalParserVisitor) VisitUidWithNestings

func (v *BaseRelationalParserVisitor) VisitUidWithNestings(ctx *UidWithNestingsContext) interface{}

func (*BaseRelationalParserVisitor) VisitUnaryOperator

func (v *BaseRelationalParserVisitor) VisitUnaryOperator(ctx *UnaryOperatorContext) interface{}

func (*BaseRelationalParserVisitor) VisitUpdateStatement

func (v *BaseRelationalParserVisitor) VisitUpdateStatement(ctx *UpdateStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitUpdatedElement

func (v *BaseRelationalParserVisitor) VisitUpdatedElement(ctx *UpdatedElementContext) interface{}

func (*BaseRelationalParserVisitor) VisitUserDefinedMacroFunctionStatementBody

func (v *BaseRelationalParserVisitor) VisitUserDefinedMacroFunctionStatementBody(ctx *UserDefinedMacroFunctionStatementBodyContext) interface{}

func (*BaseRelationalParserVisitor) VisitUserDefinedScalarFunctionCall

func (v *BaseRelationalParserVisitor) VisitUserDefinedScalarFunctionCall(ctx *UserDefinedScalarFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitUserDefinedScalarFunctionName

func (v *BaseRelationalParserVisitor) VisitUserDefinedScalarFunctionName(ctx *UserDefinedScalarFunctionNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitUserVariables

func (v *BaseRelationalParserVisitor) VisitUserVariables(ctx *UserVariablesContext) interface{}

func (*BaseRelationalParserVisitor) VisitUtilityStatement

func (v *BaseRelationalParserVisitor) VisitUtilityStatement(ctx *UtilityStatementContext) interface{}

func (*BaseRelationalParserVisitor) VisitValuesFunctionCall

func (v *BaseRelationalParserVisitor) VisitValuesFunctionCall(ctx *ValuesFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitVariableClause

func (v *BaseRelationalParserVisitor) VisitVariableClause(ctx *VariableClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitVectorElementType

func (v *BaseRelationalParserVisitor) VisitVectorElementType(ctx *VectorElementTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitVectorEngine

func (v *BaseRelationalParserVisitor) VisitVectorEngine(ctx *VectorEngineContext) interface{}

func (*BaseRelationalParserVisitor) VisitVectorIndexDefinition

func (v *BaseRelationalParserVisitor) VisitVectorIndexDefinition(ctx *VectorIndexDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitVectorIndexOption

func (v *BaseRelationalParserVisitor) VisitVectorIndexOption(ctx *VectorIndexOptionContext) interface{}

func (*BaseRelationalParserVisitor) VisitVectorIndexOptionValue

func (v *BaseRelationalParserVisitor) VisitVectorIndexOptionValue(ctx *VectorIndexOptionValueContext) interface{}

func (*BaseRelationalParserVisitor) VisitVectorIndexOptions

func (v *BaseRelationalParserVisitor) VisitVectorIndexOptions(ctx *VectorIndexOptionsContext) interface{}

func (*BaseRelationalParserVisitor) VisitVectorType

func (v *BaseRelationalParserVisitor) VisitVectorType(ctx *VectorTypeContext) interface{}

func (*BaseRelationalParserVisitor) VisitViewDefinition

func (v *BaseRelationalParserVisitor) VisitViewDefinition(ctx *ViewDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitWeightFunctionCall

func (v *BaseRelationalParserVisitor) VisitWeightFunctionCall(ctx *WeightFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitWhereExpr

func (v *BaseRelationalParserVisitor) VisitWhereExpr(ctx *WhereExprContext) interface{}

func (*BaseRelationalParserVisitor) VisitWindowName

func (v *BaseRelationalParserVisitor) VisitWindowName(ctx *WindowNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitWindowOption

func (v *BaseRelationalParserVisitor) VisitWindowOption(ctx *WindowOptionContext) interface{}

func (*BaseRelationalParserVisitor) VisitWindowOptionsClause

func (v *BaseRelationalParserVisitor) VisitWindowOptionsClause(ctx *WindowOptionsClauseContext) interface{}

func (*BaseRelationalParserVisitor) VisitWindowSpec

func (v *BaseRelationalParserVisitor) VisitWindowSpec(ctx *WindowSpecContext) interface{}

type BetweenComparisonPredicateContext

type BetweenComparisonPredicateContext struct {
	PredicateContext
	// contains filtered or unexported fields
}

func (*BetweenComparisonPredicateContext) AND

func (*BetweenComparisonPredicateContext) Accept

func (s *BetweenComparisonPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BetweenComparisonPredicateContext) AllExpressionAtom

func (*BetweenComparisonPredicateContext) BETWEEN

func (*BetweenComparisonPredicateContext) EnterRule

func (*BetweenComparisonPredicateContext) ExitRule

func (*BetweenComparisonPredicateContext) ExpressionAtom

func (*BetweenComparisonPredicateContext) GetLeft

func (*BetweenComparisonPredicateContext) GetRight

func (*BetweenComparisonPredicateContext) GetRuleContext

func (*BetweenComparisonPredicateContext) NOT

func (*BetweenComparisonPredicateContext) SetLeft

func (*BetweenComparisonPredicateContext) SetRight

type BinaryComparisonPredicateContext

type BinaryComparisonPredicateContext struct {
	ExpressionAtomContext
	// contains filtered or unexported fields
}

func NewBinaryComparisonPredicateContext

func NewBinaryComparisonPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BinaryComparisonPredicateContext

func (*BinaryComparisonPredicateContext) Accept

func (s *BinaryComparisonPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BinaryComparisonPredicateContext) AllExpressionAtom

func (*BinaryComparisonPredicateContext) ComparisonOperator

func (*BinaryComparisonPredicateContext) EnterRule

func (*BinaryComparisonPredicateContext) ExitRule

func (*BinaryComparisonPredicateContext) ExpressionAtom

func (*BinaryComparisonPredicateContext) GetLeft

func (*BinaryComparisonPredicateContext) GetRight

func (*BinaryComparisonPredicateContext) GetRuleContext

func (*BinaryComparisonPredicateContext) SetLeft

func (*BinaryComparisonPredicateContext) SetRight

type BitExpressionAtomContext

type BitExpressionAtomContext struct {
	ExpressionAtomContext
	// contains filtered or unexported fields
}

func NewBitExpressionAtomContext

func NewBitExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitExpressionAtomContext

func (*BitExpressionAtomContext) Accept

func (s *BitExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BitExpressionAtomContext) AllExpressionAtom

func (s *BitExpressionAtomContext) AllExpressionAtom() []IExpressionAtomContext

func (*BitExpressionAtomContext) BitOperator

func (*BitExpressionAtomContext) EnterRule

func (s *BitExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener)

func (*BitExpressionAtomContext) ExitRule

func (s *BitExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener)

func (*BitExpressionAtomContext) ExpressionAtom

func (*BitExpressionAtomContext) GetLeft

func (*BitExpressionAtomContext) GetRight

func (*BitExpressionAtomContext) GetRuleContext

func (s *BitExpressionAtomContext) GetRuleContext() antlr.RuleContext

func (*BitExpressionAtomContext) SetLeft

func (*BitExpressionAtomContext) SetRight

type BitOperatorContext

type BitOperatorContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBitOperatorContext

func NewBitOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitOperatorContext

func NewEmptyBitOperatorContext

func NewEmptyBitOperatorContext() *BitOperatorContext

func (*BitOperatorContext) Accept

func (s *BitOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BitOperatorContext) AllGREATER_SYMBOL

func (s *BitOperatorContext) AllGREATER_SYMBOL() []antlr.TerminalNode

func (*BitOperatorContext) AllLESS_SYMBOL

func (s *BitOperatorContext) AllLESS_SYMBOL() []antlr.TerminalNode

func (*BitOperatorContext) BIT_AND_OP

func (s *BitOperatorContext) BIT_AND_OP() antlr.TerminalNode

func (*BitOperatorContext) BIT_OR_OP

func (s *BitOperatorContext) BIT_OR_OP() antlr.TerminalNode

func (*BitOperatorContext) BIT_XOR_OP

func (s *BitOperatorContext) BIT_XOR_OP() antlr.TerminalNode

func (*BitOperatorContext) EnterRule

func (s *BitOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*BitOperatorContext) ExitRule

func (s *BitOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*BitOperatorContext) GREATER_SYMBOL

func (s *BitOperatorContext) GREATER_SYMBOL(i int) antlr.TerminalNode

func (*BitOperatorContext) GetParser

func (s *BitOperatorContext) GetParser() antlr.Parser

func (*BitOperatorContext) GetRuleContext

func (s *BitOperatorContext) GetRuleContext() antlr.RuleContext

func (*BitOperatorContext) IsBitOperatorContext

func (*BitOperatorContext) IsBitOperatorContext()

func (*BitOperatorContext) LESS_SYMBOL

func (s *BitOperatorContext) LESS_SYMBOL(i int) antlr.TerminalNode

func (*BitOperatorContext) ToStringTree

func (s *BitOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type BitStringConstantContext

type BitStringConstantContext struct {
	ConstantContext
}

func NewBitStringConstantContext

func NewBitStringConstantContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BitStringConstantContext

func (*BitStringConstantContext) Accept

func (s *BitStringConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BitStringConstantContext) BIT_STRING

func (*BitStringConstantContext) EnterRule

func (s *BitStringConstantContext) EnterRule(listener antlr.ParseTreeListener)

func (*BitStringConstantContext) ExitRule

func (s *BitStringConstantContext) ExitRule(listener antlr.ParseTreeListener)

func (*BitStringConstantContext) GetRuleContext

func (s *BitStringConstantContext) GetRuleContext() antlr.RuleContext

type BooleanConstantContext

type BooleanConstantContext struct {
	ConstantContext
}

func NewBooleanConstantContext

func NewBooleanConstantContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BooleanConstantContext

func (*BooleanConstantContext) Accept

func (s *BooleanConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BooleanConstantContext) BooleanLiteral

func (s *BooleanConstantContext) BooleanLiteral() IBooleanLiteralContext

func (*BooleanConstantContext) EnterRule

func (s *BooleanConstantContext) EnterRule(listener antlr.ParseTreeListener)

func (*BooleanConstantContext) ExitRule

func (s *BooleanConstantContext) ExitRule(listener antlr.ParseTreeListener)

func (*BooleanConstantContext) GetRuleContext

func (s *BooleanConstantContext) GetRuleContext() antlr.RuleContext

type BooleanLiteralContext

type BooleanLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBooleanLiteralContext

func NewBooleanLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanLiteralContext

func NewEmptyBooleanLiteralContext

func NewEmptyBooleanLiteralContext() *BooleanLiteralContext

func (*BooleanLiteralContext) Accept

func (s *BooleanLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BooleanLiteralContext) EnterRule

func (s *BooleanLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*BooleanLiteralContext) ExitRule

func (s *BooleanLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*BooleanLiteralContext) FALSE

func (*BooleanLiteralContext) GetParser

func (s *BooleanLiteralContext) GetParser() antlr.Parser

func (*BooleanLiteralContext) GetRuleContext

func (s *BooleanLiteralContext) GetRuleContext() antlr.RuleContext

func (*BooleanLiteralContext) IsBooleanLiteralContext

func (*BooleanLiteralContext) IsBooleanLiteralContext()

func (*BooleanLiteralContext) TRUE

func (*BooleanLiteralContext) ToStringTree

func (s *BooleanLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type BytesConstantContext

type BytesConstantContext struct {
	ConstantContext
}

func NewBytesConstantContext

func NewBytesConstantContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BytesConstantContext

func (*BytesConstantContext) Accept

func (s *BytesConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BytesConstantContext) BytesLiteral

func (s *BytesConstantContext) BytesLiteral() IBytesLiteralContext

func (*BytesConstantContext) EnterRule

func (s *BytesConstantContext) EnterRule(listener antlr.ParseTreeListener)

func (*BytesConstantContext) ExitRule

func (s *BytesConstantContext) ExitRule(listener antlr.ParseTreeListener)

func (*BytesConstantContext) GetRuleContext

func (s *BytesConstantContext) GetRuleContext() antlr.RuleContext

type BytesLiteralContext

type BytesLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBytesLiteralContext

func NewBytesLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BytesLiteralContext

func NewEmptyBytesLiteralContext

func NewEmptyBytesLiteralContext() *BytesLiteralContext

func (*BytesLiteralContext) Accept

func (s *BytesLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BytesLiteralContext) BASE64_LITERAL

func (s *BytesLiteralContext) BASE64_LITERAL() antlr.TerminalNode

func (*BytesLiteralContext) EnterRule

func (s *BytesLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*BytesLiteralContext) ExitRule

func (s *BytesLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*BytesLiteralContext) GetParser

func (s *BytesLiteralContext) GetParser() antlr.Parser

func (*BytesLiteralContext) GetRuleContext

func (s *BytesLiteralContext) GetRuleContext() antlr.RuleContext

func (*BytesLiteralContext) HEXADECIMAL_LITERAL

func (s *BytesLiteralContext) HEXADECIMAL_LITERAL() antlr.TerminalNode

func (*BytesLiteralContext) IsBytesLiteralContext

func (*BytesLiteralContext) IsBytesLiteralContext()

func (*BytesLiteralContext) ToStringTree

func (s *BytesLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CaseExpressionFunctionCallContext

type CaseExpressionFunctionCallContext struct {
	SpecificFunctionContext
	// contains filtered or unexported fields
}

func (*CaseExpressionFunctionCallContext) Accept

func (s *CaseExpressionFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CaseExpressionFunctionCallContext) AllCaseFuncAlternative

func (s *CaseExpressionFunctionCallContext) AllCaseFuncAlternative() []ICaseFuncAlternativeContext

func (*CaseExpressionFunctionCallContext) CASE

func (*CaseExpressionFunctionCallContext) CaseFuncAlternative

func (*CaseExpressionFunctionCallContext) ELSE

func (*CaseExpressionFunctionCallContext) END

func (*CaseExpressionFunctionCallContext) EnterRule

func (*CaseExpressionFunctionCallContext) ExitRule

func (*CaseExpressionFunctionCallContext) Expression

func (*CaseExpressionFunctionCallContext) FunctionArg

func (*CaseExpressionFunctionCallContext) GetElseArg

func (*CaseExpressionFunctionCallContext) GetRuleContext

func (*CaseExpressionFunctionCallContext) SetElseArg

type CaseFuncAlternativeContext

type CaseFuncAlternativeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCaseFuncAlternativeContext

func NewCaseFuncAlternativeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CaseFuncAlternativeContext

func NewEmptyCaseFuncAlternativeContext

func NewEmptyCaseFuncAlternativeContext() *CaseFuncAlternativeContext

func (*CaseFuncAlternativeContext) Accept

func (s *CaseFuncAlternativeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CaseFuncAlternativeContext) AllFunctionArg

func (s *CaseFuncAlternativeContext) AllFunctionArg() []IFunctionArgContext

func (*CaseFuncAlternativeContext) EnterRule

func (s *CaseFuncAlternativeContext) EnterRule(listener antlr.ParseTreeListener)

func (*CaseFuncAlternativeContext) ExitRule

func (s *CaseFuncAlternativeContext) ExitRule(listener antlr.ParseTreeListener)

func (*CaseFuncAlternativeContext) FunctionArg

func (*CaseFuncAlternativeContext) GetCondition

func (*CaseFuncAlternativeContext) GetConsequent

func (*CaseFuncAlternativeContext) GetParser

func (s *CaseFuncAlternativeContext) GetParser() antlr.Parser

func (*CaseFuncAlternativeContext) GetRuleContext

func (s *CaseFuncAlternativeContext) GetRuleContext() antlr.RuleContext

func (*CaseFuncAlternativeContext) IsCaseFuncAlternativeContext

func (*CaseFuncAlternativeContext) IsCaseFuncAlternativeContext()

func (*CaseFuncAlternativeContext) SetCondition

func (*CaseFuncAlternativeContext) SetConsequent

func (s *CaseFuncAlternativeContext) SetConsequent(v IFunctionArgContext)

func (*CaseFuncAlternativeContext) THEN

func (*CaseFuncAlternativeContext) ToStringTree

func (s *CaseFuncAlternativeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*CaseFuncAlternativeContext) WHEN

type CaseFunctionCallContext

type CaseFunctionCallContext struct {
	SpecificFunctionContext
	// contains filtered or unexported fields
}

func NewCaseFunctionCallContext

func NewCaseFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CaseFunctionCallContext

func (*CaseFunctionCallContext) Accept

func (s *CaseFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CaseFunctionCallContext) AllCaseFuncAlternative

func (s *CaseFunctionCallContext) AllCaseFuncAlternative() []ICaseFuncAlternativeContext

func (*CaseFunctionCallContext) CASE

func (*CaseFunctionCallContext) CaseFuncAlternative

func (s *CaseFunctionCallContext) CaseFuncAlternative(i int) ICaseFuncAlternativeContext

func (*CaseFunctionCallContext) ELSE

func (*CaseFunctionCallContext) END

func (*CaseFunctionCallContext) EnterRule

func (s *CaseFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*CaseFunctionCallContext) ExitRule

func (s *CaseFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*CaseFunctionCallContext) FunctionArg

func (*CaseFunctionCallContext) GetElseArg

func (*CaseFunctionCallContext) GetRuleContext

func (s *CaseFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*CaseFunctionCallContext) SetElseArg

type CharFunctionCallContext

type CharFunctionCallContext struct {
	SpecificFunctionContext
}

func NewCharFunctionCallContext

func NewCharFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CharFunctionCallContext

func (*CharFunctionCallContext) Accept

func (s *CharFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CharFunctionCallContext) CHAR

func (*CharFunctionCallContext) CharsetName

func (*CharFunctionCallContext) EnterRule

func (s *CharFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*CharFunctionCallContext) ExitRule

func (s *CharFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*CharFunctionCallContext) FunctionArgs

func (*CharFunctionCallContext) GetRuleContext

func (s *CharFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*CharFunctionCallContext) LEFT_ROUND_BRACKET

func (s *CharFunctionCallContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*CharFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *CharFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*CharFunctionCallContext) USING

type CharSetContext

type CharSetContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCharSetContext

func NewCharSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharSetContext

func NewEmptyCharSetContext

func NewEmptyCharSetContext() *CharSetContext

func (*CharSetContext) Accept

func (s *CharSetContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CharSetContext) CHAR

func (s *CharSetContext) CHAR() antlr.TerminalNode

func (*CharSetContext) CHARACTER

func (s *CharSetContext) CHARACTER() antlr.TerminalNode

func (*CharSetContext) CHARSET

func (s *CharSetContext) CHARSET() antlr.TerminalNode

func (*CharSetContext) EnterRule

func (s *CharSetContext) EnterRule(listener antlr.ParseTreeListener)

func (*CharSetContext) ExitRule

func (s *CharSetContext) ExitRule(listener antlr.ParseTreeListener)

func (*CharSetContext) GetParser

func (s *CharSetContext) GetParser() antlr.Parser

func (*CharSetContext) GetRuleContext

func (s *CharSetContext) GetRuleContext() antlr.RuleContext

func (*CharSetContext) IsCharSetContext

func (*CharSetContext) IsCharSetContext()

func (*CharSetContext) SET

func (*CharSetContext) ToStringTree

func (s *CharSetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CharsetNameBaseContext

type CharsetNameBaseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCharsetNameBaseContext

func NewCharsetNameBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharsetNameBaseContext

func NewEmptyCharsetNameBaseContext

func NewEmptyCharsetNameBaseContext() *CharsetNameBaseContext

func (*CharsetNameBaseContext) ARMSCII8

func (*CharsetNameBaseContext) ASCII

func (*CharsetNameBaseContext) Accept

func (s *CharsetNameBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CharsetNameBaseContext) BIG5

func (*CharsetNameBaseContext) BINARY

func (*CharsetNameBaseContext) CP850

func (*CharsetNameBaseContext) CP852

func (*CharsetNameBaseContext) CP866

func (*CharsetNameBaseContext) CP932

func (*CharsetNameBaseContext) CP1250

func (*CharsetNameBaseContext) CP1251

func (*CharsetNameBaseContext) CP1256

func (*CharsetNameBaseContext) CP1257

func (*CharsetNameBaseContext) DEC8

func (*CharsetNameBaseContext) EUCJPMS

func (*CharsetNameBaseContext) EUCKR

func (*CharsetNameBaseContext) EnterRule

func (s *CharsetNameBaseContext) EnterRule(listener antlr.ParseTreeListener)

func (*CharsetNameBaseContext) ExitRule

func (s *CharsetNameBaseContext) ExitRule(listener antlr.ParseTreeListener)

func (*CharsetNameBaseContext) GB2312

func (*CharsetNameBaseContext) GB18030

func (*CharsetNameBaseContext) GBK

func (*CharsetNameBaseContext) GEOSTD8

func (*CharsetNameBaseContext) GREEK

func (*CharsetNameBaseContext) GetParser

func (s *CharsetNameBaseContext) GetParser() antlr.Parser

func (*CharsetNameBaseContext) GetRuleContext

func (s *CharsetNameBaseContext) GetRuleContext() antlr.RuleContext

func (*CharsetNameBaseContext) HEBREW

func (*CharsetNameBaseContext) HP8

func (*CharsetNameBaseContext) IsCharsetNameBaseContext

func (*CharsetNameBaseContext) IsCharsetNameBaseContext()

func (*CharsetNameBaseContext) KEYBCS2

func (*CharsetNameBaseContext) KOI8R

func (*CharsetNameBaseContext) KOI8U

func (*CharsetNameBaseContext) LATIN1

func (*CharsetNameBaseContext) LATIN2

func (*CharsetNameBaseContext) LATIN5

func (*CharsetNameBaseContext) LATIN7

func (*CharsetNameBaseContext) MACCE

func (*CharsetNameBaseContext) MACROMAN

func (*CharsetNameBaseContext) SJIS

func (*CharsetNameBaseContext) SWE7

func (*CharsetNameBaseContext) TIS620

func (*CharsetNameBaseContext) ToStringTree

func (s *CharsetNameBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*CharsetNameBaseContext) UCS2

func (*CharsetNameBaseContext) UJIS

func (*CharsetNameBaseContext) UTF8

func (*CharsetNameBaseContext) UTF8MB3

func (*CharsetNameBaseContext) UTF8MB4

func (*CharsetNameBaseContext) UTF16

func (*CharsetNameBaseContext) UTF16LE

func (*CharsetNameBaseContext) UTF32

type CharsetNameContext

type CharsetNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCharsetNameContext

func NewCharsetNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharsetNameContext

func NewEmptyCharsetNameContext

func NewEmptyCharsetNameContext() *CharsetNameContext

func (*CharsetNameContext) Accept

func (s *CharsetNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CharsetNameContext) BINARY

func (*CharsetNameContext) CharsetNameBase

func (s *CharsetNameContext) CharsetNameBase() ICharsetNameBaseContext

func (*CharsetNameContext) EnterRule

func (s *CharsetNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*CharsetNameContext) ExitRule

func (s *CharsetNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*CharsetNameContext) GetParser

func (s *CharsetNameContext) GetParser() antlr.Parser

func (*CharsetNameContext) GetRuleContext

func (s *CharsetNameContext) GetRuleContext() antlr.RuleContext

func (*CharsetNameContext) IsCharsetNameContext

func (*CharsetNameContext) IsCharsetNameContext()

func (*CharsetNameContext) STRING_LITERAL

func (s *CharsetNameContext) STRING_LITERAL() antlr.TerminalNode

func (*CharsetNameContext) ToStringTree

func (s *CharsetNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CollationNameContext

type CollationNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollationNameContext

func NewCollationNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollationNameContext

func NewEmptyCollationNameContext

func NewEmptyCollationNameContext() *CollationNameContext

func (*CollationNameContext) Accept

func (s *CollationNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CollationNameContext) EnterRule

func (s *CollationNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollationNameContext) ExitRule

func (s *CollationNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollationNameContext) GetParser

func (s *CollationNameContext) GetParser() antlr.Parser

func (*CollationNameContext) GetRuleContext

func (s *CollationNameContext) GetRuleContext() antlr.RuleContext

func (*CollationNameContext) IsCollationNameContext

func (*CollationNameContext) IsCollationNameContext()

func (*CollationNameContext) STRING_LITERAL

func (s *CollationNameContext) STRING_LITERAL() antlr.TerminalNode

func (*CollationNameContext) ToStringTree

func (s *CollationNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*CollationNameContext) Uid

type CollectionDataTypeContext

type CollectionDataTypeContext struct {
	DataTypeContext
	// contains filtered or unexported fields
}

func NewCollectionDataTypeContext

func NewCollectionDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CollectionDataTypeContext

func (*CollectionDataTypeContext) Accept

func (s *CollectionDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CollectionDataTypeContext) BINARY

func (*CollectionDataTypeContext) CharSet

func (*CollectionDataTypeContext) CharsetName

func (*CollectionDataTypeContext) CollectionOptions

func (*CollectionDataTypeContext) ENUM

func (*CollectionDataTypeContext) EnterRule

func (s *CollectionDataTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectionDataTypeContext) ExitRule

func (s *CollectionDataTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectionDataTypeContext) GetRuleContext

func (s *CollectionDataTypeContext) GetRuleContext() antlr.RuleContext

func (*CollectionDataTypeContext) GetTypeName

func (s *CollectionDataTypeContext) GetTypeName() antlr.Token

func (*CollectionDataTypeContext) SET

func (*CollectionDataTypeContext) SetTypeName

func (s *CollectionDataTypeContext) SetTypeName(v antlr.Token)

type CollectionOptionsContext

type CollectionOptionsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollectionOptionsContext

func NewCollectionOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectionOptionsContext

func NewEmptyCollectionOptionsContext

func NewEmptyCollectionOptionsContext() *CollectionOptionsContext

func (*CollectionOptionsContext) Accept

func (s *CollectionOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CollectionOptionsContext) AllCOMMA

func (*CollectionOptionsContext) AllSTRING_LITERAL

func (s *CollectionOptionsContext) AllSTRING_LITERAL() []antlr.TerminalNode

func (*CollectionOptionsContext) COMMA

func (*CollectionOptionsContext) EnterRule

func (s *CollectionOptionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectionOptionsContext) ExitRule

func (s *CollectionOptionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectionOptionsContext) GetParser

func (s *CollectionOptionsContext) GetParser() antlr.Parser

func (*CollectionOptionsContext) GetRuleContext

func (s *CollectionOptionsContext) GetRuleContext() antlr.RuleContext

func (*CollectionOptionsContext) IsCollectionOptionsContext

func (*CollectionOptionsContext) IsCollectionOptionsContext()

func (*CollectionOptionsContext) LEFT_ROUND_BRACKET

func (s *CollectionOptionsContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*CollectionOptionsContext) RIGHT_ROUND_BRACKET

func (s *CollectionOptionsContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*CollectionOptionsContext) STRING_LITERAL

func (s *CollectionOptionsContext) STRING_LITERAL(i int) antlr.TerminalNode

func (*CollectionOptionsContext) ToStringTree

func (s *CollectionOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ColumnConstraintContext

type ColumnConstraintContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewColumnConstraintContext

func NewColumnConstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnConstraintContext

func NewEmptyColumnConstraintContext

func NewEmptyColumnConstraintContext() *ColumnConstraintContext

func (*ColumnConstraintContext) CopyAll

func (*ColumnConstraintContext) GetParser

func (s *ColumnConstraintContext) GetParser() antlr.Parser

func (*ColumnConstraintContext) GetRuleContext

func (s *ColumnConstraintContext) GetRuleContext() antlr.RuleContext

func (*ColumnConstraintContext) IsColumnConstraintContext

func (*ColumnConstraintContext) IsColumnConstraintContext()

func (*ColumnConstraintContext) ToStringTree

func (s *ColumnConstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ColumnDefinitionContext

type ColumnDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewColumnDefinitionContext

func NewColumnDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefinitionContext

func NewEmptyColumnDefinitionContext

func NewEmptyColumnDefinitionContext() *ColumnDefinitionContext

func (*ColumnDefinitionContext) ARRAY

func (*ColumnDefinitionContext) Accept

func (s *ColumnDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ColumnDefinitionContext) ColumnConstraint

func (s *ColumnDefinitionContext) ColumnConstraint() IColumnConstraintContext

func (*ColumnDefinitionContext) ColumnType

func (*ColumnDefinitionContext) EnterRule

func (s *ColumnDefinitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ColumnDefinitionContext) ExitRule

func (s *ColumnDefinitionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ColumnDefinitionContext) GetColName

func (s *ColumnDefinitionContext) GetColName() IUidContext

func (*ColumnDefinitionContext) GetParser

func (s *ColumnDefinitionContext) GetParser() antlr.Parser

func (*ColumnDefinitionContext) GetRuleContext

func (s *ColumnDefinitionContext) GetRuleContext() antlr.RuleContext

func (*ColumnDefinitionContext) IsColumnDefinitionContext

func (*ColumnDefinitionContext) IsColumnDefinitionContext()

func (*ColumnDefinitionContext) SetColName

func (s *ColumnDefinitionContext) SetColName(v IUidContext)

func (*ColumnDefinitionContext) ToStringTree

func (s *ColumnDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ColumnDefinitionContext) Uid

type ColumnTypeContext

type ColumnTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewColumnTypeContext

func NewColumnTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnTypeContext

func NewEmptyColumnTypeContext

func NewEmptyColumnTypeContext() *ColumnTypeContext

func (*ColumnTypeContext) Accept

func (s *ColumnTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ColumnTypeContext) EnterRule

func (s *ColumnTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*ColumnTypeContext) ExitRule

func (s *ColumnTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*ColumnTypeContext) GetCustomType

func (s *ColumnTypeContext) GetCustomType() IUidContext

func (*ColumnTypeContext) GetParser

func (s *ColumnTypeContext) GetParser() antlr.Parser

func (*ColumnTypeContext) GetRuleContext

func (s *ColumnTypeContext) GetRuleContext() antlr.RuleContext

func (*ColumnTypeContext) IsColumnTypeContext

func (*ColumnTypeContext) IsColumnTypeContext()

func (*ColumnTypeContext) PrimitiveType

func (s *ColumnTypeContext) PrimitiveType() IPrimitiveTypeContext

func (*ColumnTypeContext) SetCustomType

func (s *ColumnTypeContext) SetCustomType(v IUidContext)

func (*ColumnTypeContext) ToStringTree

func (s *ColumnTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ColumnTypeContext) Uid

func (s *ColumnTypeContext) Uid() IUidContext

type CommitStatementContext

type CommitStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCommitStatementContext

func NewCommitStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommitStatementContext

func NewEmptyCommitStatementContext

func NewEmptyCommitStatementContext() *CommitStatementContext

func (*CommitStatementContext) Accept

func (s *CommitStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CommitStatementContext) COMMIT

func (*CommitStatementContext) EnterRule

func (s *CommitStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*CommitStatementContext) ExitRule

func (s *CommitStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*CommitStatementContext) GetParser

func (s *CommitStatementContext) GetParser() antlr.Parser

func (*CommitStatementContext) GetRuleContext

func (s *CommitStatementContext) GetRuleContext() antlr.RuleContext

func (*CommitStatementContext) IsCommitStatementContext

func (*CommitStatementContext) IsCommitStatementContext()

func (*CommitStatementContext) ToStringTree

func (s *CommitStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ComparisonOperatorContext

type ComparisonOperatorContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewComparisonOperatorContext

func NewComparisonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComparisonOperatorContext

func NewEmptyComparisonOperatorContext

func NewEmptyComparisonOperatorContext() *ComparisonOperatorContext

func (*ComparisonOperatorContext) Accept

func (s *ComparisonOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ComparisonOperatorContext) DISTINCT

func (*ComparisonOperatorContext) EQUAL_SYMBOL

func (s *ComparisonOperatorContext) EQUAL_SYMBOL() antlr.TerminalNode

func (*ComparisonOperatorContext) EXCLAMATION_SYMBOL

func (s *ComparisonOperatorContext) EXCLAMATION_SYMBOL() antlr.TerminalNode

func (*ComparisonOperatorContext) EnterRule

func (s *ComparisonOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*ComparisonOperatorContext) ExitRule

func (s *ComparisonOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*ComparisonOperatorContext) FROM

func (*ComparisonOperatorContext) GREATER_SYMBOL

func (s *ComparisonOperatorContext) GREATER_SYMBOL() antlr.TerminalNode

func (*ComparisonOperatorContext) GetParser

func (s *ComparisonOperatorContext) GetParser() antlr.Parser

func (*ComparisonOperatorContext) GetRuleContext

func (s *ComparisonOperatorContext) GetRuleContext() antlr.RuleContext

func (*ComparisonOperatorContext) IS

func (*ComparisonOperatorContext) IsComparisonOperatorContext

func (*ComparisonOperatorContext) IsComparisonOperatorContext()

func (*ComparisonOperatorContext) LESS_SYMBOL

func (s *ComparisonOperatorContext) LESS_SYMBOL() antlr.TerminalNode

func (*ComparisonOperatorContext) NOT

func (*ComparisonOperatorContext) ToStringTree

func (s *ComparisonOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ConstantContext

type ConstantContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewConstantContext

func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext

func NewEmptyConstantContext

func NewEmptyConstantContext() *ConstantContext

func (*ConstantContext) CopyAll

func (s *ConstantContext) CopyAll(ctx *ConstantContext)

func (*ConstantContext) GetParser

func (s *ConstantContext) GetParser() antlr.Parser

func (*ConstantContext) GetRuleContext

func (s *ConstantContext) GetRuleContext() antlr.RuleContext

func (*ConstantContext) IsConstantContext

func (*ConstantContext) IsConstantContext()

func (*ConstantContext) ToStringTree

func (s *ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ConstantExpressionAtomContext

type ConstantExpressionAtomContext struct {
	ExpressionAtomContext
}

func NewConstantExpressionAtomContext

func NewConstantExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ConstantExpressionAtomContext

func (*ConstantExpressionAtomContext) Accept

func (s *ConstantExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ConstantExpressionAtomContext) Constant

func (*ConstantExpressionAtomContext) EnterRule

func (s *ConstantExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener)

func (*ConstantExpressionAtomContext) ExitRule

func (*ConstantExpressionAtomContext) GetRuleContext

func (s *ConstantExpressionAtomContext) GetRuleContext() antlr.RuleContext

type ContinuationAtomContext

type ContinuationAtomContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewContinuationAtomContext

func NewContinuationAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ContinuationAtomContext

func NewEmptyContinuationAtomContext

func NewEmptyContinuationAtomContext() *ContinuationAtomContext

func (*ContinuationAtomContext) Accept

func (s *ContinuationAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ContinuationAtomContext) BytesLiteral

func (*ContinuationAtomContext) EnterRule

func (s *ContinuationAtomContext) EnterRule(listener antlr.ParseTreeListener)

func (*ContinuationAtomContext) ExitRule

func (s *ContinuationAtomContext) ExitRule(listener antlr.ParseTreeListener)

func (*ContinuationAtomContext) GetParser

func (s *ContinuationAtomContext) GetParser() antlr.Parser

func (*ContinuationAtomContext) GetRuleContext

func (s *ContinuationAtomContext) GetRuleContext() antlr.RuleContext

func (*ContinuationAtomContext) IsContinuationAtomContext

func (*ContinuationAtomContext) IsContinuationAtomContext()

func (*ContinuationAtomContext) PreparedStatementParameter

func (s *ContinuationAtomContext) PreparedStatementParameter() IPreparedStatementParameterContext

func (*ContinuationAtomContext) ToStringTree

func (s *ContinuationAtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ConvertedDataTypeContext

type ConvertedDataTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewConvertedDataTypeContext

func NewConvertedDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConvertedDataTypeContext

func NewEmptyConvertedDataTypeContext

func NewEmptyConvertedDataTypeContext() *ConvertedDataTypeContext

func (*ConvertedDataTypeContext) ARRAY

func (*ConvertedDataTypeContext) Accept

func (s *ConvertedDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ConvertedDataTypeContext) EnterRule

func (s *ConvertedDataTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*ConvertedDataTypeContext) ExitRule

func (s *ConvertedDataTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*ConvertedDataTypeContext) GetParser

func (s *ConvertedDataTypeContext) GetParser() antlr.Parser

func (*ConvertedDataTypeContext) GetRuleContext

func (s *ConvertedDataTypeContext) GetRuleContext() antlr.RuleContext

func (*ConvertedDataTypeContext) GetTypeName

func (*ConvertedDataTypeContext) IsConvertedDataTypeContext

func (*ConvertedDataTypeContext) IsConvertedDataTypeContext()

func (*ConvertedDataTypeContext) PrimitiveType

func (*ConvertedDataTypeContext) SetTypeName

func (*ConvertedDataTypeContext) ToStringTree

func (s *ConvertedDataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CopyExportStatementContext

type CopyExportStatementContext struct {
	CopyStatementContext
}

func NewCopyExportStatementContext

func NewCopyExportStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CopyExportStatementContext

func (*CopyExportStatementContext) Accept

func (s *CopyExportStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CopyExportStatementContext) COPY

func (*CopyExportStatementContext) EnterRule

func (s *CopyExportStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*CopyExportStatementContext) ExitRule

func (s *CopyExportStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*CopyExportStatementContext) GetRuleContext

func (s *CopyExportStatementContext) GetRuleContext() antlr.RuleContext

func (*CopyExportStatementContext) Path

type CopyImportStatementContext

type CopyImportStatementContext struct {
	CopyStatementContext
}

func NewCopyImportStatementContext

func NewCopyImportStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CopyImportStatementContext

func (*CopyImportStatementContext) Accept

func (s *CopyImportStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CopyImportStatementContext) COPY

func (*CopyImportStatementContext) EnterRule

func (s *CopyImportStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*CopyImportStatementContext) ExitRule

func (s *CopyImportStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*CopyImportStatementContext) FROM

func (*CopyImportStatementContext) GetRuleContext

func (s *CopyImportStatementContext) GetRuleContext() antlr.RuleContext

func (*CopyImportStatementContext) Path

func (*CopyImportStatementContext) PreparedStatementParameter

func (s *CopyImportStatementContext) PreparedStatementParameter() IPreparedStatementParameterContext

type CopyStatementContext

type CopyStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCopyStatementContext

func NewCopyStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CopyStatementContext

func NewEmptyCopyStatementContext

func NewEmptyCopyStatementContext() *CopyStatementContext

func (*CopyStatementContext) CopyAll

func (s *CopyStatementContext) CopyAll(ctx *CopyStatementContext)

func (*CopyStatementContext) GetParser

func (s *CopyStatementContext) GetParser() antlr.Parser

func (*CopyStatementContext) GetRuleContext

func (s *CopyStatementContext) GetRuleContext() antlr.RuleContext

func (*CopyStatementContext) IsCopyStatementContext

func (*CopyStatementContext) IsCopyStatementContext()

func (*CopyStatementContext) ToStringTree

func (s *CopyStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CreateDatabaseStatementContext

type CreateDatabaseStatementContext struct {
	CreateStatementContext
}

func NewCreateDatabaseStatementContext

func NewCreateDatabaseStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateDatabaseStatementContext

func (*CreateDatabaseStatementContext) Accept

func (s *CreateDatabaseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CreateDatabaseStatementContext) CREATE

func (*CreateDatabaseStatementContext) DATABASE

func (*CreateDatabaseStatementContext) EnterRule

func (*CreateDatabaseStatementContext) ExitRule

func (*CreateDatabaseStatementContext) GetRuleContext

func (s *CreateDatabaseStatementContext) GetRuleContext() antlr.RuleContext

func (*CreateDatabaseStatementContext) Path

type CreateSchemaStatementContext

type CreateSchemaStatementContext struct {
	CreateStatementContext
}

func NewCreateSchemaStatementContext

func NewCreateSchemaStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CreateSchemaStatementContext

func (*CreateSchemaStatementContext) Accept

func (s *CreateSchemaStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CreateSchemaStatementContext) CREATE

func (*CreateSchemaStatementContext) EnterRule

func (s *CreateSchemaStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*CreateSchemaStatementContext) ExitRule

func (*CreateSchemaStatementContext) GetRuleContext

func (s *CreateSchemaStatementContext) GetRuleContext() antlr.RuleContext

func (*CreateSchemaStatementContext) SCHEMA

func (*CreateSchemaStatementContext) SchemaId

func (*CreateSchemaStatementContext) SchemaTemplateId

func (*CreateSchemaStatementContext) TEMPLATE

func (*CreateSchemaStatementContext) WITH

type CreateSchemaTemplateStatementContext

type CreateSchemaTemplateStatementContext struct {
	CreateStatementContext
}

func (*CreateSchemaTemplateStatementContext) Accept

func (s *CreateSchemaTemplateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CreateSchemaTemplateStatementContext) AllTemplateClause

func (*CreateSchemaTemplateStatementContext) CREATE

func (*CreateSchemaTemplateStatementContext) EnterRule

func (*CreateSchemaTemplateStatementContext) ExitRule

func (*CreateSchemaTemplateStatementContext) GetRuleContext

func (*CreateSchemaTemplateStatementContext) OptionsClause

func (*CreateSchemaTemplateStatementContext) SCHEMA

func (*CreateSchemaTemplateStatementContext) SchemaTemplateId

func (*CreateSchemaTemplateStatementContext) TEMPLATE

func (*CreateSchemaTemplateStatementContext) TemplateClause

type CreateStatementContext

type CreateStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCreateStatementContext

func NewCreateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateStatementContext

func NewEmptyCreateStatementContext

func NewEmptyCreateStatementContext() *CreateStatementContext

func (*CreateStatementContext) CopyAll

func (*CreateStatementContext) GetParser

func (s *CreateStatementContext) GetParser() antlr.Parser

func (*CreateStatementContext) GetRuleContext

func (s *CreateStatementContext) GetRuleContext() antlr.RuleContext

func (*CreateStatementContext) IsCreateStatementContext

func (*CreateStatementContext) IsCreateStatementContext()

func (*CreateStatementContext) ToStringTree

func (s *CreateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CreateTempFunctionContext

type CreateTempFunctionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCreateTempFunctionContext

func NewCreateTempFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateTempFunctionContext

func NewEmptyCreateTempFunctionContext

func NewEmptyCreateTempFunctionContext() *CreateTempFunctionContext

func (*CreateTempFunctionContext) Accept

func (s *CreateTempFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CreateTempFunctionContext) CREATE

func (*CreateTempFunctionContext) EnterRule

func (s *CreateTempFunctionContext) EnterRule(listener antlr.ParseTreeListener)

func (*CreateTempFunctionContext) ExitRule

func (s *CreateTempFunctionContext) ExitRule(listener antlr.ParseTreeListener)

func (*CreateTempFunctionContext) GetParser

func (s *CreateTempFunctionContext) GetParser() antlr.Parser

func (*CreateTempFunctionContext) GetRuleContext

func (s *CreateTempFunctionContext) GetRuleContext() antlr.RuleContext

func (*CreateTempFunctionContext) IsCreateTempFunctionContext

func (*CreateTempFunctionContext) IsCreateTempFunctionContext()

func (*CreateTempFunctionContext) OR

func (*CreateTempFunctionContext) REPLACE

func (*CreateTempFunctionContext) TEMPORARY

func (*CreateTempFunctionContext) TempSqlInvokedFunction

func (s *CreateTempFunctionContext) TempSqlInvokedFunction() ITempSqlInvokedFunctionContext

func (*CreateTempFunctionContext) ToStringTree

func (s *CreateTempFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CtesContext

type CtesContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCtesContext

func NewCtesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CtesContext

func NewEmptyCtesContext

func NewEmptyCtesContext() *CtesContext

func (*CtesContext) Accept

func (s *CtesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CtesContext) AllCOMMA

func (s *CtesContext) AllCOMMA() []antlr.TerminalNode

func (*CtesContext) AllNamedQuery

func (s *CtesContext) AllNamedQuery() []INamedQueryContext

func (*CtesContext) COMMA

func (s *CtesContext) COMMA(i int) antlr.TerminalNode

func (*CtesContext) EnterRule

func (s *CtesContext) EnterRule(listener antlr.ParseTreeListener)

func (*CtesContext) ExitRule

func (s *CtesContext) ExitRule(listener antlr.ParseTreeListener)

func (*CtesContext) GetParser

func (s *CtesContext) GetParser() antlr.Parser

func (*CtesContext) GetRuleContext

func (s *CtesContext) GetRuleContext() antlr.RuleContext

func (*CtesContext) IsCtesContext

func (*CtesContext) IsCtesContext()

func (*CtesContext) NamedQuery

func (s *CtesContext) NamedQuery(i int) INamedQueryContext

func (*CtesContext) RECURSIVE

func (s *CtesContext) RECURSIVE() antlr.TerminalNode

func (*CtesContext) ToStringTree

func (s *CtesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*CtesContext) TraversalOrderClause

func (s *CtesContext) TraversalOrderClause() ITraversalOrderClauseContext

func (*CtesContext) WITH

func (s *CtesContext) WITH() antlr.TerminalNode

type CurrentTimestampContext

type CurrentTimestampContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCurrentTimestampContext

func NewCurrentTimestampContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CurrentTimestampContext

func NewEmptyCurrentTimestampContext

func NewEmptyCurrentTimestampContext() *CurrentTimestampContext

func (*CurrentTimestampContext) Accept

func (s *CurrentTimestampContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CurrentTimestampContext) CURRENT_TIMESTAMP

func (s *CurrentTimestampContext) CURRENT_TIMESTAMP() antlr.TerminalNode

func (*CurrentTimestampContext) DecimalLiteral

func (s *CurrentTimestampContext) DecimalLiteral() IDecimalLiteralContext

func (*CurrentTimestampContext) EnterRule

func (s *CurrentTimestampContext) EnterRule(listener antlr.ParseTreeListener)

func (*CurrentTimestampContext) ExitRule

func (s *CurrentTimestampContext) ExitRule(listener antlr.ParseTreeListener)

func (*CurrentTimestampContext) GetParser

func (s *CurrentTimestampContext) GetParser() antlr.Parser

func (*CurrentTimestampContext) GetRuleContext

func (s *CurrentTimestampContext) GetRuleContext() antlr.RuleContext

func (*CurrentTimestampContext) IsCurrentTimestampContext

func (*CurrentTimestampContext) IsCurrentTimestampContext()

func (*CurrentTimestampContext) LEFT_ROUND_BRACKET

func (s *CurrentTimestampContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*CurrentTimestampContext) LOCALTIME

func (*CurrentTimestampContext) LOCALTIMESTAMP

func (s *CurrentTimestampContext) LOCALTIMESTAMP() antlr.TerminalNode

func (*CurrentTimestampContext) NOW

func (*CurrentTimestampContext) RIGHT_ROUND_BRACKET

func (s *CurrentTimestampContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*CurrentTimestampContext) ToStringTree

func (s *CurrentTimestampContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type DataTypeContext

type DataTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDataTypeContext

func NewDataTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DataTypeContext

func NewEmptyDataTypeContext

func NewEmptyDataTypeContext() *DataTypeContext

func (*DataTypeContext) CopyAll

func (s *DataTypeContext) CopyAll(ctx *DataTypeContext)

func (*DataTypeContext) GetParser

func (s *DataTypeContext) GetParser() antlr.Parser

func (*DataTypeContext) GetRuleContext

func (s *DataTypeContext) GetRuleContext() antlr.RuleContext

func (*DataTypeContext) IsDataTypeContext

func (*DataTypeContext) IsDataTypeContext()

func (*DataTypeContext) ToStringTree

func (s *DataTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type DataTypeFunctionCallContext

type DataTypeFunctionCallContext struct {
	SpecificFunctionContext
	// contains filtered or unexported fields
}

func NewDataTypeFunctionCallContext

func NewDataTypeFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DataTypeFunctionCallContext

func (*DataTypeFunctionCallContext) AS

func (*DataTypeFunctionCallContext) Accept

func (s *DataTypeFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DataTypeFunctionCallContext) CAST

func (*DataTypeFunctionCallContext) COMMA

func (*DataTypeFunctionCallContext) CONVERT

func (*DataTypeFunctionCallContext) CharsetName

func (*DataTypeFunctionCallContext) ConvertedDataType

func (*DataTypeFunctionCallContext) EnterRule

func (s *DataTypeFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*DataTypeFunctionCallContext) ExitRule

func (s *DataTypeFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*DataTypeFunctionCallContext) Expression

func (*DataTypeFunctionCallContext) GetRuleContext

func (s *DataTypeFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*DataTypeFunctionCallContext) GetSeparator

func (s *DataTypeFunctionCallContext) GetSeparator() antlr.Token

func (*DataTypeFunctionCallContext) LEFT_ROUND_BRACKET

func (s *DataTypeFunctionCallContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*DataTypeFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *DataTypeFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*DataTypeFunctionCallContext) SetSeparator

func (s *DataTypeFunctionCallContext) SetSeparator(v antlr.Token)

func (*DataTypeFunctionCallContext) USING

type DdlStatementContext

type DdlStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDdlStatementContext

func NewDdlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DdlStatementContext

func NewEmptyDdlStatementContext

func NewEmptyDdlStatementContext() *DdlStatementContext

func (*DdlStatementContext) Accept

func (s *DdlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DdlStatementContext) CreateStatement

func (s *DdlStatementContext) CreateStatement() ICreateStatementContext

func (*DdlStatementContext) CreateTempFunction

func (s *DdlStatementContext) CreateTempFunction() ICreateTempFunctionContext

func (*DdlStatementContext) DropStatement

func (s *DdlStatementContext) DropStatement() IDropStatementContext

func (*DdlStatementContext) DropTempFunction

func (s *DdlStatementContext) DropTempFunction() IDropTempFunctionContext

func (*DdlStatementContext) EnterRule

func (s *DdlStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*DdlStatementContext) ExitRule

func (s *DdlStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*DdlStatementContext) GetParser

func (s *DdlStatementContext) GetParser() antlr.Parser

func (*DdlStatementContext) GetRuleContext

func (s *DdlStatementContext) GetRuleContext() antlr.RuleContext

func (*DdlStatementContext) IsDdlStatementContext

func (*DdlStatementContext) IsDdlStatementContext()

func (*DdlStatementContext) ToStringTree

func (s *DdlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type DecimalConstantContext

type DecimalConstantContext struct {
	ConstantContext
}

func NewDecimalConstantContext

func NewDecimalConstantContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DecimalConstantContext

func (*DecimalConstantContext) Accept

func (s *DecimalConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DecimalConstantContext) DecimalLiteral

func (s *DecimalConstantContext) DecimalLiteral() IDecimalLiteralContext

func (*DecimalConstantContext) EnterRule

func (s *DecimalConstantContext) EnterRule(listener antlr.ParseTreeListener)

func (*DecimalConstantContext) ExitRule

func (s *DecimalConstantContext) ExitRule(listener antlr.ParseTreeListener)

func (*DecimalConstantContext) GetRuleContext

func (s *DecimalConstantContext) GetRuleContext() antlr.RuleContext

type DecimalLiteralContext

type DecimalLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDecimalLiteralContext

func NewDecimalLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DecimalLiteralContext

func NewEmptyDecimalLiteralContext

func NewEmptyDecimalLiteralContext() *DecimalLiteralContext

func (*DecimalLiteralContext) Accept

func (s *DecimalLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DecimalLiteralContext) DECIMAL_LITERAL

func (s *DecimalLiteralContext) DECIMAL_LITERAL() antlr.TerminalNode

func (*DecimalLiteralContext) EnterRule

func (s *DecimalLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*DecimalLiteralContext) ExitRule

func (s *DecimalLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*DecimalLiteralContext) GetParser

func (s *DecimalLiteralContext) GetParser() antlr.Parser

func (*DecimalLiteralContext) GetRuleContext

func (s *DecimalLiteralContext) GetRuleContext() antlr.RuleContext

func (*DecimalLiteralContext) IsDecimalLiteralContext

func (*DecimalLiteralContext) IsDecimalLiteralContext()

func (*DecimalLiteralContext) REAL_LITERAL

func (s *DecimalLiteralContext) REAL_LITERAL() antlr.TerminalNode

func (*DecimalLiteralContext) ToStringTree

func (s *DecimalLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type DeclareBlockContext

type DeclareBlockContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeclareBlockContext

func NewDeclareBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclareBlockContext

func NewEmptyDeclareBlockContext

func NewEmptyDeclareBlockContext() *DeclareBlockContext

func (*DeclareBlockContext) Accept

func (s *DeclareBlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DeclareBlockContext) AllDeclaredFunction

func (s *DeclareBlockContext) AllDeclaredFunction() []IDeclaredFunctionContext

func (*DeclareBlockContext) AllSEMI

func (s *DeclareBlockContext) AllSEMI() []antlr.TerminalNode

func (*DeclareBlockContext) DECLARE

func (s *DeclareBlockContext) DECLARE() antlr.TerminalNode

func (*DeclareBlockContext) DeclaredFunction

func (s *DeclareBlockContext) DeclaredFunction(i int) IDeclaredFunctionContext

func (*DeclareBlockContext) EnterRule

func (s *DeclareBlockContext) EnterRule(listener antlr.ParseTreeListener)

func (*DeclareBlockContext) ExitRule

func (s *DeclareBlockContext) ExitRule(listener antlr.ParseTreeListener)

func (*DeclareBlockContext) GetParser

func (s *DeclareBlockContext) GetParser() antlr.Parser

func (*DeclareBlockContext) GetRuleContext

func (s *DeclareBlockContext) GetRuleContext() antlr.RuleContext

func (*DeclareBlockContext) IsDeclareBlockContext

func (*DeclareBlockContext) IsDeclareBlockContext()

func (*DeclareBlockContext) SEMI

func (*DeclareBlockContext) ToStringTree

func (s *DeclareBlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type DeclaredFunctionContext

type DeclaredFunctionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeclaredFunctionContext

func NewDeclaredFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclaredFunctionContext

func NewEmptyDeclaredFunctionContext

func NewEmptyDeclaredFunctionContext() *DeclaredFunctionContext

func (*DeclaredFunctionContext) AS

func (*DeclaredFunctionContext) Accept

func (s *DeclaredFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DeclaredFunctionContext) EnterRule

func (s *DeclaredFunctionContext) EnterRule(listener antlr.ParseTreeListener)

func (*DeclaredFunctionContext) ExitRule

func (s *DeclaredFunctionContext) ExitRule(listener antlr.ParseTreeListener)

func (*DeclaredFunctionContext) FUNCTION

func (*DeclaredFunctionContext) GetFunctionBody

func (s *DeclaredFunctionContext) GetFunctionBody() IQueryContext

func (*DeclaredFunctionContext) GetFunctionName

func (s *DeclaredFunctionContext) GetFunctionName() IUidContext

func (*DeclaredFunctionContext) GetParser

func (s *DeclaredFunctionContext) GetParser() antlr.Parser

func (*DeclaredFunctionContext) GetRuleContext

func (s *DeclaredFunctionContext) GetRuleContext() antlr.RuleContext

func (*DeclaredFunctionContext) IsDeclaredFunctionContext

func (*DeclaredFunctionContext) IsDeclaredFunctionContext()

func (*DeclaredFunctionContext) LEFT_ROUND_BRACKET

func (s *DeclaredFunctionContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*DeclaredFunctionContext) Query

func (*DeclaredFunctionContext) RIGHT_ROUND_BRACKET

func (s *DeclaredFunctionContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*DeclaredFunctionContext) SetFunctionBody

func (s *DeclaredFunctionContext) SetFunctionBody(v IQueryContext)

func (*DeclaredFunctionContext) SetFunctionName

func (s *DeclaredFunctionContext) SetFunctionName(v IUidContext)

func (*DeclaredFunctionContext) SqlParameterDeclarationList

func (s *DeclaredFunctionContext) SqlParameterDeclarationList() ISqlParameterDeclarationListContext

func (*DeclaredFunctionContext) ToStringTree

func (s *DeclaredFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*DeclaredFunctionContext) Uid

type DefaultValueContext

type DefaultValueContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDefaultValueContext

func NewDefaultValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaultValueContext

func NewEmptyDefaultValueContext

func NewEmptyDefaultValueContext() *DefaultValueContext

func (*DefaultValueContext) Accept

func (s *DefaultValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DefaultValueContext) AllCurrentTimestamp

func (s *DefaultValueContext) AllCurrentTimestamp() []ICurrentTimestampContext

func (*DefaultValueContext) Constant

func (s *DefaultValueContext) Constant() IConstantContext

func (*DefaultValueContext) CurrentTimestamp

func (s *DefaultValueContext) CurrentTimestamp(i int) ICurrentTimestampContext

func (*DefaultValueContext) EnterRule

func (s *DefaultValueContext) EnterRule(listener antlr.ParseTreeListener)

func (*DefaultValueContext) ExitRule

func (s *DefaultValueContext) ExitRule(listener antlr.ParseTreeListener)

func (*DefaultValueContext) Expression

func (s *DefaultValueContext) Expression() IExpressionContext

func (*DefaultValueContext) GetParser

func (s *DefaultValueContext) GetParser() antlr.Parser

func (*DefaultValueContext) GetRuleContext

func (s *DefaultValueContext) GetRuleContext() antlr.RuleContext

func (*DefaultValueContext) IsDefaultValueContext

func (*DefaultValueContext) IsDefaultValueContext()

func (*DefaultValueContext) LEFT_ROUND_BRACKET

func (s *DefaultValueContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*DefaultValueContext) NULL_LITERAL

func (s *DefaultValueContext) NULL_LITERAL() antlr.TerminalNode

func (*DefaultValueContext) ON

func (*DefaultValueContext) RIGHT_ROUND_BRACKET

func (s *DefaultValueContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*DefaultValueContext) ToStringTree

func (s *DefaultValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*DefaultValueContext) UPDATE

func (*DefaultValueContext) UnaryOperator

func (s *DefaultValueContext) UnaryOperator() IUnaryOperatorContext

type DeleteStatementContext

type DeleteStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeleteStatementContext

func NewDeleteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeleteStatementContext

func NewEmptyDeleteStatementContext

func NewEmptyDeleteStatementContext() *DeleteStatementContext

func (*DeleteStatementContext) Accept

func (s *DeleteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DeleteStatementContext) DELETE

func (*DeleteStatementContext) EnterRule

func (s *DeleteStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*DeleteStatementContext) ExitRule

func (s *DeleteStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*DeleteStatementContext) FROM

func (*DeleteStatementContext) GetParser

func (s *DeleteStatementContext) GetParser() antlr.Parser

func (*DeleteStatementContext) GetRuleContext

func (s *DeleteStatementContext) GetRuleContext() antlr.RuleContext

func (*DeleteStatementContext) IsDeleteStatementContext

func (*DeleteStatementContext) IsDeleteStatementContext()

func (*DeleteStatementContext) LimitClause

func (*DeleteStatementContext) OrderByClause

func (s *DeleteStatementContext) OrderByClause() IOrderByClauseContext

func (*DeleteStatementContext) RETURNING

func (s *DeleteStatementContext) RETURNING() antlr.TerminalNode

func (*DeleteStatementContext) SelectElements

func (s *DeleteStatementContext) SelectElements() ISelectElementsContext

func (*DeleteStatementContext) StatementOptions

func (s *DeleteStatementContext) StatementOptions() IStatementOptionsContext

func (*DeleteStatementContext) TableName

func (*DeleteStatementContext) ToStringTree

func (s *DeleteStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*DeleteStatementContext) WHERE

func (*DeleteStatementContext) WhereExpr

type DescribeConnectionContext

type DescribeConnectionContext struct {
	DescribeObjectClauseContext
}

func NewDescribeConnectionContext

func NewDescribeConnectionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DescribeConnectionContext

func (*DescribeConnectionContext) Accept

func (s *DescribeConnectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DescribeConnectionContext) CONNECTION

func (*DescribeConnectionContext) EnterRule

func (s *DescribeConnectionContext) EnterRule(listener antlr.ParseTreeListener)

func (*DescribeConnectionContext) ExitRule

func (s *DescribeConnectionContext) ExitRule(listener antlr.ParseTreeListener)

func (*DescribeConnectionContext) FOR

func (*DescribeConnectionContext) GetRuleContext

func (s *DescribeConnectionContext) GetRuleContext() antlr.RuleContext

func (*DescribeConnectionContext) Uid

type DescribeObjectClauseContext

type DescribeObjectClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDescribeObjectClauseContext

func NewDescribeObjectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DescribeObjectClauseContext

func NewEmptyDescribeObjectClauseContext

func NewEmptyDescribeObjectClauseContext() *DescribeObjectClauseContext

func (*DescribeObjectClauseContext) CopyAll

func (*DescribeObjectClauseContext) GetParser

func (s *DescribeObjectClauseContext) GetParser() antlr.Parser

func (*DescribeObjectClauseContext) GetRuleContext

func (s *DescribeObjectClauseContext) GetRuleContext() antlr.RuleContext

func (*DescribeObjectClauseContext) IsDescribeObjectClauseContext

func (*DescribeObjectClauseContext) IsDescribeObjectClauseContext()

func (*DescribeObjectClauseContext) ToStringTree

func (s *DescribeObjectClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type DescribeStatementsContext

type DescribeStatementsContext struct {
	DescribeObjectClauseContext
}

func NewDescribeStatementsContext

func NewDescribeStatementsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DescribeStatementsContext

func (*DescribeStatementsContext) Accept

func (s *DescribeStatementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DescribeStatementsContext) DeleteStatement

func (*DescribeStatementsContext) EnterRule

func (s *DescribeStatementsContext) EnterRule(listener antlr.ParseTreeListener)

func (*DescribeStatementsContext) ExecuteContinuationStatement

func (s *DescribeStatementsContext) ExecuteContinuationStatement() IExecuteContinuationStatementContext

func (*DescribeStatementsContext) ExitRule

func (s *DescribeStatementsContext) ExitRule(listener antlr.ParseTreeListener)

func (*DescribeStatementsContext) GetRuleContext

func (s *DescribeStatementsContext) GetRuleContext() antlr.RuleContext

func (*DescribeStatementsContext) InsertStatement

func (*DescribeStatementsContext) Query

func (*DescribeStatementsContext) StatementOptions

func (*DescribeStatementsContext) UpdateStatement

type DeterministicCharacteristicContext

type DeterministicCharacteristicContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeterministicCharacteristicContext

func NewDeterministicCharacteristicContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeterministicCharacteristicContext

func NewEmptyDeterministicCharacteristicContext

func NewEmptyDeterministicCharacteristicContext() *DeterministicCharacteristicContext

func (*DeterministicCharacteristicContext) Accept

func (s *DeterministicCharacteristicContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DeterministicCharacteristicContext) DETERMINISTIC

func (*DeterministicCharacteristicContext) EnterRule

func (*DeterministicCharacteristicContext) ExitRule

func (*DeterministicCharacteristicContext) GetParser

func (*DeterministicCharacteristicContext) GetRuleContext

func (*DeterministicCharacteristicContext) IsDeterministicCharacteristicContext

func (*DeterministicCharacteristicContext) IsDeterministicCharacteristicContext()

func (*DeterministicCharacteristicContext) NOT

func (*DeterministicCharacteristicContext) ToStringTree

func (s *DeterministicCharacteristicContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type DimensionDataTypeContext

type DimensionDataTypeContext struct {
	DataTypeContext
	// contains filtered or unexported fields
}

func NewDimensionDataTypeContext

func NewDimensionDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DimensionDataTypeContext

func (*DimensionDataTypeContext) Accept

func (s *DimensionDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DimensionDataTypeContext) AllSIGNED

func (s *DimensionDataTypeContext) AllSIGNED() []antlr.TerminalNode

func (*DimensionDataTypeContext) AllUNSIGNED

func (s *DimensionDataTypeContext) AllUNSIGNED() []antlr.TerminalNode

func (*DimensionDataTypeContext) AllZEROFILL

func (s *DimensionDataTypeContext) AllZEROFILL() []antlr.TerminalNode

func (*DimensionDataTypeContext) BIGINT

func (*DimensionDataTypeContext) BINARY

func (*DimensionDataTypeContext) BIT

func (*DimensionDataTypeContext) BLOB

func (*DimensionDataTypeContext) DATETIME

func (*DimensionDataTypeContext) DEC

func (*DimensionDataTypeContext) DECIMAL

func (*DimensionDataTypeContext) DOUBLE

func (*DimensionDataTypeContext) EnterRule

func (s *DimensionDataTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*DimensionDataTypeContext) ExitRule

func (s *DimensionDataTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*DimensionDataTypeContext) FIXED

func (*DimensionDataTypeContext) FLOAT

func (*DimensionDataTypeContext) FLOAT4

func (*DimensionDataTypeContext) FLOAT8

func (*DimensionDataTypeContext) GetRuleContext

func (s *DimensionDataTypeContext) GetRuleContext() antlr.RuleContext

func (*DimensionDataTypeContext) GetTypeName

func (s *DimensionDataTypeContext) GetTypeName() antlr.Token

func (*DimensionDataTypeContext) INT

func (*DimensionDataTypeContext) INT1

func (*DimensionDataTypeContext) INT2

func (*DimensionDataTypeContext) INT3

func (*DimensionDataTypeContext) INT4

func (*DimensionDataTypeContext) INT8

func (*DimensionDataTypeContext) INTEGER

func (*DimensionDataTypeContext) LengthOneDimension

func (s *DimensionDataTypeContext) LengthOneDimension() ILengthOneDimensionContext

func (*DimensionDataTypeContext) LengthTwoDimension

func (s *DimensionDataTypeContext) LengthTwoDimension() ILengthTwoDimensionContext

func (*DimensionDataTypeContext) LengthTwoOptionalDimension

func (s *DimensionDataTypeContext) LengthTwoOptionalDimension() ILengthTwoOptionalDimensionContext

func (*DimensionDataTypeContext) MEDIUMINT

func (*DimensionDataTypeContext) MIDDLEINT

func (*DimensionDataTypeContext) NUMERIC

func (*DimensionDataTypeContext) PRECISION

func (*DimensionDataTypeContext) REAL

func (*DimensionDataTypeContext) SIGNED

func (*DimensionDataTypeContext) SMALLINT

func (*DimensionDataTypeContext) SetTypeName

func (s *DimensionDataTypeContext) SetTypeName(v antlr.Token)

func (*DimensionDataTypeContext) TIME

func (*DimensionDataTypeContext) TIMESTAMP

func (*DimensionDataTypeContext) TINYINT

func (*DimensionDataTypeContext) UNSIGNED

func (*DimensionDataTypeContext) VARBINARY

func (*DimensionDataTypeContext) YEAR

func (*DimensionDataTypeContext) ZEROFILL

type DispatchClauseContext

type DispatchClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDispatchClauseContext

func NewDispatchClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DispatchClauseContext

func NewEmptyDispatchClauseContext

func NewEmptyDispatchClauseContext() *DispatchClauseContext

func (*DispatchClauseContext) Accept

func (s *DispatchClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DispatchClauseContext) DISPATCH

func (*DispatchClauseContext) EnterRule

func (s *DispatchClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*DispatchClauseContext) ExitRule

func (s *DispatchClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*DispatchClauseContext) GetParser

func (s *DispatchClauseContext) GetParser() antlr.Parser

func (*DispatchClauseContext) GetRuleContext

func (s *DispatchClauseContext) GetRuleContext() antlr.RuleContext

func (*DispatchClauseContext) IsDispatchClauseContext

func (*DispatchClauseContext) IsDispatchClauseContext()

func (*DispatchClauseContext) STATIC

func (*DispatchClauseContext) ToStringTree

func (s *DispatchClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type DmlStatementContext

type DmlStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDmlStatementContext

func NewDmlStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DmlStatementContext

func NewEmptyDmlStatementContext

func NewEmptyDmlStatementContext() *DmlStatementContext

func (*DmlStatementContext) Accept

func (s *DmlStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DmlStatementContext) DeleteStatement

func (s *DmlStatementContext) DeleteStatement() IDeleteStatementContext

func (*DmlStatementContext) EnterRule

func (s *DmlStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*DmlStatementContext) ExitRule

func (s *DmlStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*DmlStatementContext) GetParser

func (s *DmlStatementContext) GetParser() antlr.Parser

func (*DmlStatementContext) GetRuleContext

func (s *DmlStatementContext) GetRuleContext() antlr.RuleContext

func (*DmlStatementContext) InsertStatement

func (s *DmlStatementContext) InsertStatement() IInsertStatementContext

func (*DmlStatementContext) IsDmlStatementContext

func (*DmlStatementContext) IsDmlStatementContext()

func (*DmlStatementContext) ToStringTree

func (s *DmlStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*DmlStatementContext) UpdateStatement

func (s *DmlStatementContext) UpdateStatement() IUpdateStatementContext

type DropDatabaseStatementContext

type DropDatabaseStatementContext struct {
	DropStatementContext
}

func NewDropDatabaseStatementContext

func NewDropDatabaseStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropDatabaseStatementContext

func (*DropDatabaseStatementContext) Accept

func (s *DropDatabaseStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DropDatabaseStatementContext) DATABASE

func (*DropDatabaseStatementContext) DROP

func (*DropDatabaseStatementContext) EnterRule

func (s *DropDatabaseStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*DropDatabaseStatementContext) ExitRule

func (*DropDatabaseStatementContext) GetRuleContext

func (s *DropDatabaseStatementContext) GetRuleContext() antlr.RuleContext

func (*DropDatabaseStatementContext) IfExists

func (*DropDatabaseStatementContext) Path

type DropSchemaStatementContext

type DropSchemaStatementContext struct {
	DropStatementContext
}

func NewDropSchemaStatementContext

func NewDropSchemaStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DropSchemaStatementContext

func (*DropSchemaStatementContext) Accept

func (s *DropSchemaStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DropSchemaStatementContext) DROP

func (*DropSchemaStatementContext) EnterRule

func (s *DropSchemaStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*DropSchemaStatementContext) ExitRule

func (s *DropSchemaStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*DropSchemaStatementContext) GetRuleContext

func (s *DropSchemaStatementContext) GetRuleContext() antlr.RuleContext

func (*DropSchemaStatementContext) IfExists

func (*DropSchemaStatementContext) SCHEMA

func (*DropSchemaStatementContext) Uid

type DropSchemaTemplateStatementContext

type DropSchemaTemplateStatementContext struct {
	DropStatementContext
}

func (*DropSchemaTemplateStatementContext) Accept

func (s *DropSchemaTemplateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DropSchemaTemplateStatementContext) DROP

func (*DropSchemaTemplateStatementContext) EnterRule

func (*DropSchemaTemplateStatementContext) ExitRule

func (*DropSchemaTemplateStatementContext) GetRuleContext

func (*DropSchemaTemplateStatementContext) IfExists

func (*DropSchemaTemplateStatementContext) SCHEMA

func (*DropSchemaTemplateStatementContext) TEMPLATE

func (*DropSchemaTemplateStatementContext) Uid

type DropStatementContext

type DropStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDropStatementContext

func NewDropStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropStatementContext

func NewEmptyDropStatementContext

func NewEmptyDropStatementContext() *DropStatementContext

func (*DropStatementContext) CopyAll

func (s *DropStatementContext) CopyAll(ctx *DropStatementContext)

func (*DropStatementContext) GetParser

func (s *DropStatementContext) GetParser() antlr.Parser

func (*DropStatementContext) GetRuleContext

func (s *DropStatementContext) GetRuleContext() antlr.RuleContext

func (*DropStatementContext) IsDropStatementContext

func (*DropStatementContext) IsDropStatementContext()

func (*DropStatementContext) ToStringTree

func (s *DropStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type DropTempFunctionContext

type DropTempFunctionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDropTempFunctionContext

func NewDropTempFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropTempFunctionContext

func NewEmptyDropTempFunctionContext

func NewEmptyDropTempFunctionContext() *DropTempFunctionContext

func (*DropTempFunctionContext) Accept

func (s *DropTempFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*DropTempFunctionContext) DROP

func (*DropTempFunctionContext) EXISTS

func (*DropTempFunctionContext) EnterRule

func (s *DropTempFunctionContext) EnterRule(listener antlr.ParseTreeListener)

func (*DropTempFunctionContext) ExitRule

func (s *DropTempFunctionContext) ExitRule(listener antlr.ParseTreeListener)

func (*DropTempFunctionContext) FUNCTION

func (*DropTempFunctionContext) FullId

func (*DropTempFunctionContext) GetParser

func (s *DropTempFunctionContext) GetParser() antlr.Parser

func (*DropTempFunctionContext) GetRuleContext

func (s *DropTempFunctionContext) GetRuleContext() antlr.RuleContext

func (*DropTempFunctionContext) GetSchemaQualifiedRoutineName

func (s *DropTempFunctionContext) GetSchemaQualifiedRoutineName() IFullIdContext

func (*DropTempFunctionContext) IF

func (*DropTempFunctionContext) IsDropTempFunctionContext

func (*DropTempFunctionContext) IsDropTempFunctionContext()

func (*DropTempFunctionContext) SetSchemaQualifiedRoutineName

func (s *DropTempFunctionContext) SetSchemaQualifiedRoutineName(v IFullIdContext)

func (*DropTempFunctionContext) TEMPORARY

func (*DropTempFunctionContext) ToStringTree

func (s *DropTempFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EnumDefinitionContext

type EnumDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnumDefinitionContext

func NewEmptyEnumDefinitionContext() *EnumDefinitionContext

func NewEnumDefinitionContext

func NewEnumDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnumDefinitionContext

func (*EnumDefinitionContext) AS

func (*EnumDefinitionContext) Accept

func (s *EnumDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EnumDefinitionContext) AllCOMMA

func (s *EnumDefinitionContext) AllCOMMA() []antlr.TerminalNode

func (*EnumDefinitionContext) AllSTRING_LITERAL

func (s *EnumDefinitionContext) AllSTRING_LITERAL() []antlr.TerminalNode

func (*EnumDefinitionContext) COMMA

func (*EnumDefinitionContext) ENUM

func (*EnumDefinitionContext) EnterRule

func (s *EnumDefinitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*EnumDefinitionContext) ExitRule

func (s *EnumDefinitionContext) ExitRule(listener antlr.ParseTreeListener)

func (*EnumDefinitionContext) GetParser

func (s *EnumDefinitionContext) GetParser() antlr.Parser

func (*EnumDefinitionContext) GetRuleContext

func (s *EnumDefinitionContext) GetRuleContext() antlr.RuleContext

func (*EnumDefinitionContext) IsEnumDefinitionContext

func (*EnumDefinitionContext) IsEnumDefinitionContext()

func (*EnumDefinitionContext) LEFT_ROUND_BRACKET

func (s *EnumDefinitionContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*EnumDefinitionContext) RIGHT_ROUND_BRACKET

func (s *EnumDefinitionContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*EnumDefinitionContext) STRING_LITERAL

func (s *EnumDefinitionContext) STRING_LITERAL(i int) antlr.TerminalNode

func (*EnumDefinitionContext) TYPE

func (*EnumDefinitionContext) ToStringTree

func (s *EnumDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*EnumDefinitionContext) Uid

type ExecuteContinuationStatementContext

type ExecuteContinuationStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExecuteContinuationStatementContext

func NewEmptyExecuteContinuationStatementContext() *ExecuteContinuationStatementContext

func NewExecuteContinuationStatementContext

func NewExecuteContinuationStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExecuteContinuationStatementContext

func (*ExecuteContinuationStatementContext) Accept

func (s *ExecuteContinuationStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExecuteContinuationStatementContext) CONTINUATION

func (*ExecuteContinuationStatementContext) ContinuationAtom

func (*ExecuteContinuationStatementContext) EXECUTE

func (*ExecuteContinuationStatementContext) EnterRule

func (*ExecuteContinuationStatementContext) ExitRule

func (*ExecuteContinuationStatementContext) GetPackageBytes

func (*ExecuteContinuationStatementContext) GetParser

func (*ExecuteContinuationStatementContext) GetRuleContext

func (*ExecuteContinuationStatementContext) IsExecuteContinuationStatementContext

func (*ExecuteContinuationStatementContext) IsExecuteContinuationStatementContext()

func (*ExecuteContinuationStatementContext) SetPackageBytes

func (*ExecuteContinuationStatementContext) StatementOptions

func (*ExecuteContinuationStatementContext) ToStringTree

func (s *ExecuteContinuationStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ExecuteStatementContext

type ExecuteStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExecuteStatementContext

func NewEmptyExecuteStatementContext() *ExecuteStatementContext

func NewExecuteStatementContext

func NewExecuteStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExecuteStatementContext

func (*ExecuteStatementContext) Accept

func (s *ExecuteStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExecuteStatementContext) EXECUTE

func (*ExecuteStatementContext) EnterRule

func (s *ExecuteStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*ExecuteStatementContext) ExitRule

func (s *ExecuteStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*ExecuteStatementContext) GetParser

func (s *ExecuteStatementContext) GetParser() antlr.Parser

func (*ExecuteStatementContext) GetRuleContext

func (s *ExecuteStatementContext) GetRuleContext() antlr.RuleContext

func (*ExecuteStatementContext) IsExecuteStatementContext

func (*ExecuteStatementContext) IsExecuteStatementContext()

func (*ExecuteStatementContext) ToStringTree

func (s *ExecuteStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ExecuteStatementContext) USING

func (*ExecuteStatementContext) Uid

func (*ExecuteStatementContext) UserVariables

type ExistsExpressionAtomContext

type ExistsExpressionAtomContext struct {
	ExpressionContext
}

func NewExistsExpressionAtomContext

func NewExistsExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExistsExpressionAtomContext

func (*ExistsExpressionAtomContext) Accept

func (s *ExistsExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExistsExpressionAtomContext) EXISTS

func (*ExistsExpressionAtomContext) EnterRule

func (s *ExistsExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener)

func (*ExistsExpressionAtomContext) ExitRule

func (s *ExistsExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener)

func (*ExistsExpressionAtomContext) GetRuleContext

func (s *ExistsExpressionAtomContext) GetRuleContext() antlr.RuleContext

func (*ExistsExpressionAtomContext) LEFT_ROUND_BRACKET

func (s *ExistsExpressionAtomContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*ExistsExpressionAtomContext) Query

func (*ExistsExpressionAtomContext) RIGHT_ROUND_BRACKET

func (s *ExistsExpressionAtomContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

type ExpressionAtomContext

type ExpressionAtomContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpressionAtomContext

func NewEmptyExpressionAtomContext() *ExpressionAtomContext

func NewExpressionAtomContext

func NewExpressionAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionAtomContext

func (*ExpressionAtomContext) CopyAll

func (*ExpressionAtomContext) GetParser

func (s *ExpressionAtomContext) GetParser() antlr.Parser

func (*ExpressionAtomContext) GetRuleContext

func (s *ExpressionAtomContext) GetRuleContext() antlr.RuleContext

func (*ExpressionAtomContext) IsExpressionAtomContext

func (*ExpressionAtomContext) IsExpressionAtomContext()

func (*ExpressionAtomContext) ToStringTree

func (s *ExpressionAtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ExpressionContext

type ExpressionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpressionContext

func NewEmptyExpressionContext() *ExpressionContext

func NewExpressionContext

func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext

func (*ExpressionContext) CopyAll

func (s *ExpressionContext) CopyAll(ctx *ExpressionContext)

func (*ExpressionContext) GetParser

func (s *ExpressionContext) GetParser() antlr.Parser

func (*ExpressionContext) GetRuleContext

func (s *ExpressionContext) GetRuleContext() antlr.RuleContext

func (*ExpressionContext) IsExpressionContext

func (*ExpressionContext) IsExpressionContext()

func (*ExpressionContext) ToStringTree

func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ExpressionOrDefaultContext

type ExpressionOrDefaultContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpressionOrDefaultContext

func NewEmptyExpressionOrDefaultContext() *ExpressionOrDefaultContext

func NewExpressionOrDefaultContext

func NewExpressionOrDefaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionOrDefaultContext

func (*ExpressionOrDefaultContext) Accept

func (s *ExpressionOrDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExpressionOrDefaultContext) DEFAULT

func (*ExpressionOrDefaultContext) EnterRule

func (s *ExpressionOrDefaultContext) EnterRule(listener antlr.ParseTreeListener)

func (*ExpressionOrDefaultContext) ExitRule

func (s *ExpressionOrDefaultContext) ExitRule(listener antlr.ParseTreeListener)

func (*ExpressionOrDefaultContext) Expression

func (*ExpressionOrDefaultContext) GetParser

func (s *ExpressionOrDefaultContext) GetParser() antlr.Parser

func (*ExpressionOrDefaultContext) GetRuleContext

func (s *ExpressionOrDefaultContext) GetRuleContext() antlr.RuleContext

func (*ExpressionOrDefaultContext) IsExpressionOrDefaultContext

func (*ExpressionOrDefaultContext) IsExpressionOrDefaultContext()

func (*ExpressionOrDefaultContext) ToStringTree

func (s *ExpressionOrDefaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ExpressionWithOptionalNameContext

type ExpressionWithOptionalNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpressionWithOptionalNameContext

func NewEmptyExpressionWithOptionalNameContext() *ExpressionWithOptionalNameContext

func NewExpressionWithOptionalNameContext

func NewExpressionWithOptionalNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionWithOptionalNameContext

func (*ExpressionWithOptionalNameContext) AS

func (*ExpressionWithOptionalNameContext) Accept

func (s *ExpressionWithOptionalNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExpressionWithOptionalNameContext) EnterRule

func (*ExpressionWithOptionalNameContext) ExitRule

func (*ExpressionWithOptionalNameContext) Expression

func (*ExpressionWithOptionalNameContext) GetParser

func (*ExpressionWithOptionalNameContext) GetRuleContext

func (*ExpressionWithOptionalNameContext) IsExpressionWithOptionalNameContext

func (*ExpressionWithOptionalNameContext) IsExpressionWithOptionalNameContext()

func (*ExpressionWithOptionalNameContext) ToStringTree

func (s *ExpressionWithOptionalNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ExpressionWithOptionalNameContext) Uid

type ExpressionsContext

type ExpressionsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpressionsContext

func NewEmptyExpressionsContext() *ExpressionsContext

func NewExpressionsContext

func NewExpressionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionsContext

func (*ExpressionsContext) Accept

func (s *ExpressionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExpressionsContext) AllCOMMA

func (s *ExpressionsContext) AllCOMMA() []antlr.TerminalNode

func (*ExpressionsContext) AllExpression

func (s *ExpressionsContext) AllExpression() []IExpressionContext

func (*ExpressionsContext) COMMA

func (*ExpressionsContext) EnterRule

func (s *ExpressionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*ExpressionsContext) ExitRule

func (s *ExpressionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*ExpressionsContext) Expression

func (s *ExpressionsContext) Expression(i int) IExpressionContext

func (*ExpressionsContext) GetParser

func (s *ExpressionsContext) GetParser() antlr.Parser

func (*ExpressionsContext) GetRuleContext

func (s *ExpressionsContext) GetRuleContext() antlr.RuleContext

func (*ExpressionsContext) IsExpressionsContext

func (*ExpressionsContext) IsExpressionsContext()

func (*ExpressionsContext) ToStringTree

func (s *ExpressionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ExpressionsWithDefaultsContext

type ExpressionsWithDefaultsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpressionsWithDefaultsContext

func NewEmptyExpressionsWithDefaultsContext() *ExpressionsWithDefaultsContext

func NewExpressionsWithDefaultsContext

func NewExpressionsWithDefaultsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionsWithDefaultsContext

func (*ExpressionsWithDefaultsContext) Accept

func (s *ExpressionsWithDefaultsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExpressionsWithDefaultsContext) AllCOMMA

func (*ExpressionsWithDefaultsContext) AllExpressionOrDefault

func (s *ExpressionsWithDefaultsContext) AllExpressionOrDefault() []IExpressionOrDefaultContext

func (*ExpressionsWithDefaultsContext) COMMA

func (*ExpressionsWithDefaultsContext) EnterRule

func (*ExpressionsWithDefaultsContext) ExitRule

func (*ExpressionsWithDefaultsContext) ExpressionOrDefault

func (*ExpressionsWithDefaultsContext) GetParser

func (*ExpressionsWithDefaultsContext) GetRuleContext

func (s *ExpressionsWithDefaultsContext) GetRuleContext() antlr.RuleContext

func (*ExpressionsWithDefaultsContext) IsExpressionsWithDefaultsContext

func (*ExpressionsWithDefaultsContext) IsExpressionsWithDefaultsContext()

func (*ExpressionsWithDefaultsContext) ToStringTree

func (s *ExpressionsWithDefaultsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ExtractFunctionCallContext

type ExtractFunctionCallContext struct {
	SpecificFunctionContext
	// contains filtered or unexported fields
}

func NewExtractFunctionCallContext

func NewExtractFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExtractFunctionCallContext

func (*ExtractFunctionCallContext) Accept

func (s *ExtractFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExtractFunctionCallContext) EXTRACT

func (*ExtractFunctionCallContext) EnterRule

func (s *ExtractFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*ExtractFunctionCallContext) ExitRule

func (s *ExtractFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*ExtractFunctionCallContext) Expression

func (*ExtractFunctionCallContext) FROM

func (*ExtractFunctionCallContext) GetRuleContext

func (s *ExtractFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*ExtractFunctionCallContext) GetSourceExpression

func (s *ExtractFunctionCallContext) GetSourceExpression() IExpressionContext

func (*ExtractFunctionCallContext) GetSourceString

func (*ExtractFunctionCallContext) IntervalType

func (*ExtractFunctionCallContext) LEFT_ROUND_BRACKET

func (s *ExtractFunctionCallContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*ExtractFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *ExtractFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*ExtractFunctionCallContext) SetSourceExpression

func (s *ExtractFunctionCallContext) SetSourceExpression(v IExpressionContext)

func (*ExtractFunctionCallContext) SetSourceString

func (s *ExtractFunctionCallContext) SetSourceString(v IStringLiteralContext)

func (*ExtractFunctionCallContext) StringLiteral

type FromClauseContext

type FromClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFromClauseContext

func NewEmptyFromClauseContext() *FromClauseContext

func NewFromClauseContext

func NewFromClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromClauseContext

func (*FromClauseContext) Accept

func (s *FromClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FromClauseContext) EnterRule

func (s *FromClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*FromClauseContext) ExitRule

func (s *FromClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*FromClauseContext) FROM

func (*FromClauseContext) GetParser

func (s *FromClauseContext) GetParser() antlr.Parser

func (*FromClauseContext) GetRuleContext

func (s *FromClauseContext) GetRuleContext() antlr.RuleContext

func (*FromClauseContext) IsFromClauseContext

func (*FromClauseContext) IsFromClauseContext()

func (*FromClauseContext) TableSources

func (s *FromClauseContext) TableSources() ITableSourcesContext

func (*FromClauseContext) ToStringTree

func (s *FromClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*FromClauseContext) WHERE

func (*FromClauseContext) WhereExpr

func (s *FromClauseContext) WhereExpr() IWhereExprContext

type FullColumnNameContext

type FullColumnNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFullColumnNameContext

func NewEmptyFullColumnNameContext() *FullColumnNameContext

func NewFullColumnNameContext

func NewFullColumnNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullColumnNameContext

func (*FullColumnNameContext) Accept

func (s *FullColumnNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FullColumnNameContext) EnterRule

func (s *FullColumnNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*FullColumnNameContext) ExitRule

func (s *FullColumnNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*FullColumnNameContext) FullId

func (*FullColumnNameContext) GetParser

func (s *FullColumnNameContext) GetParser() antlr.Parser

func (*FullColumnNameContext) GetRuleContext

func (s *FullColumnNameContext) GetRuleContext() antlr.RuleContext

func (*FullColumnNameContext) IsFullColumnNameContext

func (*FullColumnNameContext) IsFullColumnNameContext()

func (*FullColumnNameContext) ToStringTree

func (s *FullColumnNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FullColumnNameExpressionAtomContext

type FullColumnNameExpressionAtomContext struct {
	ExpressionAtomContext
}

func (*FullColumnNameExpressionAtomContext) Accept

func (s *FullColumnNameExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FullColumnNameExpressionAtomContext) EnterRule

func (*FullColumnNameExpressionAtomContext) ExitRule

func (*FullColumnNameExpressionAtomContext) FullColumnName

func (*FullColumnNameExpressionAtomContext) GetRuleContext

type FullDescribeStatementContext

type FullDescribeStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFullDescribeStatementContext

func NewEmptyFullDescribeStatementContext() *FullDescribeStatementContext

func NewFullDescribeStatementContext

func NewFullDescribeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullDescribeStatementContext

func (*FullDescribeStatementContext) Accept

func (s *FullDescribeStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FullDescribeStatementContext) DESC

func (*FullDescribeStatementContext) DESCRIBE

func (*FullDescribeStatementContext) DescribeObjectClause

func (*FullDescribeStatementContext) EQUAL_SYMBOL

func (*FullDescribeStatementContext) EXPLAIN

func (*FullDescribeStatementContext) EXTENDED

func (*FullDescribeStatementContext) EnterRule

func (s *FullDescribeStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*FullDescribeStatementContext) ExitRule

func (*FullDescribeStatementContext) FORMAT

func (*FullDescribeStatementContext) GetCommand

func (s *FullDescribeStatementContext) GetCommand() antlr.Token

func (*FullDescribeStatementContext) GetFormatType

func (s *FullDescribeStatementContext) GetFormatType() antlr.Token

func (*FullDescribeStatementContext) GetFormatValue

func (s *FullDescribeStatementContext) GetFormatValue() antlr.Token

func (*FullDescribeStatementContext) GetParser

func (s *FullDescribeStatementContext) GetParser() antlr.Parser

func (*FullDescribeStatementContext) GetRuleContext

func (s *FullDescribeStatementContext) GetRuleContext() antlr.RuleContext

func (*FullDescribeStatementContext) IsFullDescribeStatementContext

func (*FullDescribeStatementContext) IsFullDescribeStatementContext()

func (*FullDescribeStatementContext) JSON

func (*FullDescribeStatementContext) PARTITIONS

func (*FullDescribeStatementContext) SetCommand

func (s *FullDescribeStatementContext) SetCommand(v antlr.Token)

func (*FullDescribeStatementContext) SetFormatType

func (s *FullDescribeStatementContext) SetFormatType(v antlr.Token)

func (*FullDescribeStatementContext) SetFormatValue

func (s *FullDescribeStatementContext) SetFormatValue(v antlr.Token)

func (*FullDescribeStatementContext) TRADITIONAL

func (*FullDescribeStatementContext) ToStringTree

func (s *FullDescribeStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FullIdContext

type FullIdContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFullIdContext

func NewEmptyFullIdContext() *FullIdContext

func NewFullIdContext

func NewFullIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullIdContext

func (*FullIdContext) Accept

func (s *FullIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FullIdContext) AllDOT

func (s *FullIdContext) AllDOT() []antlr.TerminalNode

func (*FullIdContext) AllUid

func (s *FullIdContext) AllUid() []IUidContext

func (*FullIdContext) DOT

func (s *FullIdContext) DOT(i int) antlr.TerminalNode

func (*FullIdContext) EnterRule

func (s *FullIdContext) EnterRule(listener antlr.ParseTreeListener)

func (*FullIdContext) ExitRule

func (s *FullIdContext) ExitRule(listener antlr.ParseTreeListener)

func (*FullIdContext) GetParser

func (s *FullIdContext) GetParser() antlr.Parser

func (*FullIdContext) GetRuleContext

func (s *FullIdContext) GetRuleContext() antlr.RuleContext

func (*FullIdContext) IsFullIdContext

func (*FullIdContext) IsFullIdContext()

func (*FullIdContext) ToStringTree

func (s *FullIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*FullIdContext) Uid

func (s *FullIdContext) Uid(i int) IUidContext

type FullIdListContext

type FullIdListContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFullIdListContext

func NewEmptyFullIdListContext() *FullIdListContext

func NewFullIdListContext

func NewFullIdListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FullIdListContext

func (*FullIdListContext) Accept

func (s *FullIdListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FullIdListContext) AllCOMMA

func (s *FullIdListContext) AllCOMMA() []antlr.TerminalNode

func (*FullIdListContext) AllFullId

func (s *FullIdListContext) AllFullId() []IFullIdContext

func (*FullIdListContext) COMMA

func (*FullIdListContext) EnterRule

func (s *FullIdListContext) EnterRule(listener antlr.ParseTreeListener)

func (*FullIdListContext) ExitRule

func (s *FullIdListContext) ExitRule(listener antlr.ParseTreeListener)

func (*FullIdListContext) FullId

func (s *FullIdListContext) FullId(i int) IFullIdContext

func (*FullIdListContext) GetParser

func (s *FullIdListContext) GetParser() antlr.Parser

func (*FullIdListContext) GetRuleContext

func (s *FullIdListContext) GetRuleContext() antlr.RuleContext

func (*FullIdListContext) IsFullIdListContext

func (*FullIdListContext) IsFullIdListContext()

func (*FullIdListContext) LEFT_ROUND_BRACKET

func (s *FullIdListContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*FullIdListContext) RIGHT_ROUND_BRACKET

func (s *FullIdListContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*FullIdListContext) ToStringTree

func (s *FullIdListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FunctionArgContext

type FunctionArgContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionArgContext

func NewEmptyFunctionArgContext() *FunctionArgContext

func NewFunctionArgContext

func NewFunctionArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgContext

func (*FunctionArgContext) Accept

func (s *FunctionArgContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionArgContext) EnterRule

func (s *FunctionArgContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionArgContext) ExitRule

func (s *FunctionArgContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionArgContext) Expression

func (s *FunctionArgContext) Expression() IExpressionContext

func (*FunctionArgContext) GetParser

func (s *FunctionArgContext) GetParser() antlr.Parser

func (*FunctionArgContext) GetRuleContext

func (s *FunctionArgContext) GetRuleContext() antlr.RuleContext

func (*FunctionArgContext) IsFunctionArgContext

func (*FunctionArgContext) IsFunctionArgContext()

func (*FunctionArgContext) ToStringTree

func (s *FunctionArgContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FunctionArgsContext

type FunctionArgsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionArgsContext

func NewEmptyFunctionArgsContext() *FunctionArgsContext

func NewFunctionArgsContext

func NewFunctionArgsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionArgsContext

func (*FunctionArgsContext) Accept

func (s *FunctionArgsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionArgsContext) AllCOMMA

func (s *FunctionArgsContext) AllCOMMA() []antlr.TerminalNode

func (*FunctionArgsContext) AllFunctionArg

func (s *FunctionArgsContext) AllFunctionArg() []IFunctionArgContext

func (*FunctionArgsContext) COMMA

func (*FunctionArgsContext) EnterRule

func (s *FunctionArgsContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionArgsContext) ExitRule

func (s *FunctionArgsContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionArgsContext) FunctionArg

func (s *FunctionArgsContext) FunctionArg(i int) IFunctionArgContext

func (*FunctionArgsContext) GetParser

func (s *FunctionArgsContext) GetParser() antlr.Parser

func (*FunctionArgsContext) GetRuleContext

func (s *FunctionArgsContext) GetRuleContext() antlr.RuleContext

func (*FunctionArgsContext) IsFunctionArgsContext

func (*FunctionArgsContext) IsFunctionArgsContext()

func (*FunctionArgsContext) ToStringTree

func (s *FunctionArgsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FunctionCallContext

type FunctionCallContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionCallContext

func NewEmptyFunctionCallContext() *FunctionCallContext

func NewFunctionCallContext

func NewFunctionCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallContext

func (*FunctionCallContext) CopyAll

func (s *FunctionCallContext) CopyAll(ctx *FunctionCallContext)

func (*FunctionCallContext) GetParser

func (s *FunctionCallContext) GetParser() antlr.Parser

func (*FunctionCallContext) GetRuleContext

func (s *FunctionCallContext) GetRuleContext() antlr.RuleContext

func (*FunctionCallContext) IsFunctionCallContext

func (*FunctionCallContext) IsFunctionCallContext()

func (*FunctionCallContext) ToStringTree

func (s *FunctionCallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FunctionCallExpressionAtomContext

type FunctionCallExpressionAtomContext struct {
	ExpressionAtomContext
}

func (*FunctionCallExpressionAtomContext) Accept

func (s *FunctionCallExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionCallExpressionAtomContext) EnterRule

func (*FunctionCallExpressionAtomContext) ExitRule

func (*FunctionCallExpressionAtomContext) FunctionCall

func (*FunctionCallExpressionAtomContext) GetRuleContext

type FunctionColumnTypeContext

type FunctionColumnTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionColumnTypeContext

func NewEmptyFunctionColumnTypeContext() *FunctionColumnTypeContext

func NewFunctionColumnTypeContext

func NewFunctionColumnTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionColumnTypeContext

func (*FunctionColumnTypeContext) ARRAY

func (*FunctionColumnTypeContext) Accept

func (s *FunctionColumnTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionColumnTypeContext) EnterRule

func (s *FunctionColumnTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionColumnTypeContext) ExitRule

func (s *FunctionColumnTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionColumnTypeContext) GetCustomType

func (s *FunctionColumnTypeContext) GetCustomType() IUidContext

func (*FunctionColumnTypeContext) GetParser

func (s *FunctionColumnTypeContext) GetParser() antlr.Parser

func (*FunctionColumnTypeContext) GetRuleContext

func (s *FunctionColumnTypeContext) GetRuleContext() antlr.RuleContext

func (*FunctionColumnTypeContext) IsFunctionColumnTypeContext

func (*FunctionColumnTypeContext) IsFunctionColumnTypeContext()

func (*FunctionColumnTypeContext) PrimitiveType

func (*FunctionColumnTypeContext) SetCustomType

func (s *FunctionColumnTypeContext) SetCustomType(v IUidContext)

func (*FunctionColumnTypeContext) TYPE

func (*FunctionColumnTypeContext) ToStringTree

func (s *FunctionColumnTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*FunctionColumnTypeContext) Uid

type FunctionNameBaseContext

type FunctionNameBaseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionNameBaseContext

func NewEmptyFunctionNameBaseContext() *FunctionNameBaseContext

func NewFunctionNameBaseContext

func NewFunctionNameBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionNameBaseContext

func (*FunctionNameBaseContext) ABS

func (*FunctionNameBaseContext) ACOS

func (*FunctionNameBaseContext) ADDDATE

func (*FunctionNameBaseContext) ADDTIME

func (*FunctionNameBaseContext) AES_DECRYPT

func (s *FunctionNameBaseContext) AES_DECRYPT() antlr.TerminalNode

func (*FunctionNameBaseContext) AES_ENCRYPT

func (s *FunctionNameBaseContext) AES_ENCRYPT() antlr.TerminalNode

func (*FunctionNameBaseContext) AREA

func (*FunctionNameBaseContext) ASBINARY

func (*FunctionNameBaseContext) ASIN

func (*FunctionNameBaseContext) ASTEXT

func (*FunctionNameBaseContext) ASWKB

func (*FunctionNameBaseContext) ASWKT

func (*FunctionNameBaseContext) ASYMMETRIC_DECRYPT

func (s *FunctionNameBaseContext) ASYMMETRIC_DECRYPT() antlr.TerminalNode

func (*FunctionNameBaseContext) ASYMMETRIC_DERIVE

func (s *FunctionNameBaseContext) ASYMMETRIC_DERIVE() antlr.TerminalNode

func (*FunctionNameBaseContext) ASYMMETRIC_ENCRYPT

func (s *FunctionNameBaseContext) ASYMMETRIC_ENCRYPT() antlr.TerminalNode

func (*FunctionNameBaseContext) ASYMMETRIC_SIGN

func (s *FunctionNameBaseContext) ASYMMETRIC_SIGN() antlr.TerminalNode

func (*FunctionNameBaseContext) ASYMMETRIC_VERIFY

func (s *FunctionNameBaseContext) ASYMMETRIC_VERIFY() antlr.TerminalNode

func (*FunctionNameBaseContext) ATAN

func (*FunctionNameBaseContext) ATAN2

func (*FunctionNameBaseContext) Accept

func (s *FunctionNameBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionNameBaseContext) BENCHMARK

func (*FunctionNameBaseContext) BIN

func (*FunctionNameBaseContext) BITMAP_BIT_POSITION

func (s *FunctionNameBaseContext) BITMAP_BIT_POSITION() antlr.TerminalNode

func (*FunctionNameBaseContext) BITMAP_BUCKET_NUMBER

func (s *FunctionNameBaseContext) BITMAP_BUCKET_NUMBER() antlr.TerminalNode

func (*FunctionNameBaseContext) BITMAP_BUCKET_OFFSET

func (s *FunctionNameBaseContext) BITMAP_BUCKET_OFFSET() antlr.TerminalNode

func (*FunctionNameBaseContext) BIT_COUNT

func (*FunctionNameBaseContext) BIT_LENGTH

func (s *FunctionNameBaseContext) BIT_LENGTH() antlr.TerminalNode

func (*FunctionNameBaseContext) BUFFER

func (*FunctionNameBaseContext) CEIL

func (*FunctionNameBaseContext) CEILING

func (*FunctionNameBaseContext) CENTROID

func (*FunctionNameBaseContext) CHARACTER_LENGTH

func (s *FunctionNameBaseContext) CHARACTER_LENGTH() antlr.TerminalNode

func (*FunctionNameBaseContext) CHARSET

func (*FunctionNameBaseContext) CHAR_LENGTH

func (s *FunctionNameBaseContext) CHAR_LENGTH() antlr.TerminalNode

func (*FunctionNameBaseContext) COALESCE

func (*FunctionNameBaseContext) COERCIBILITY

func (s *FunctionNameBaseContext) COERCIBILITY() antlr.TerminalNode

func (*FunctionNameBaseContext) COLLATION

func (*FunctionNameBaseContext) COMPRESS

func (*FunctionNameBaseContext) CONCAT

func (*FunctionNameBaseContext) CONCAT_WS

func (*FunctionNameBaseContext) CONNECTION_ID

func (s *FunctionNameBaseContext) CONNECTION_ID() antlr.TerminalNode

func (*FunctionNameBaseContext) CONV

func (*FunctionNameBaseContext) CONVERT_TZ

func (s *FunctionNameBaseContext) CONVERT_TZ() antlr.TerminalNode

func (*FunctionNameBaseContext) COS

func (*FunctionNameBaseContext) COSINE_DISTANCE

func (s *FunctionNameBaseContext) COSINE_DISTANCE() antlr.TerminalNode

func (*FunctionNameBaseContext) COT

func (*FunctionNameBaseContext) CRC32

func (*FunctionNameBaseContext) CREATE_ASYMMETRIC_PRIV_KEY

func (s *FunctionNameBaseContext) CREATE_ASYMMETRIC_PRIV_KEY() antlr.TerminalNode

func (*FunctionNameBaseContext) CREATE_ASYMMETRIC_PUB_KEY

func (s *FunctionNameBaseContext) CREATE_ASYMMETRIC_PUB_KEY() antlr.TerminalNode

func (*FunctionNameBaseContext) CREATE_DH_PARAMETERS

func (s *FunctionNameBaseContext) CREATE_DH_PARAMETERS() antlr.TerminalNode

func (*FunctionNameBaseContext) CREATE_DIGEST

func (s *FunctionNameBaseContext) CREATE_DIGEST() antlr.TerminalNode

func (*FunctionNameBaseContext) CROSSES

func (*FunctionNameBaseContext) CUME_DIST

func (*FunctionNameBaseContext) DATABASE

func (*FunctionNameBaseContext) DATE

func (*FunctionNameBaseContext) DATEDIFF

func (*FunctionNameBaseContext) DATE_FORMAT

func (s *FunctionNameBaseContext) DATE_FORMAT() antlr.TerminalNode

func (*FunctionNameBaseContext) DAY

func (*FunctionNameBaseContext) DAYNAME

func (*FunctionNameBaseContext) DAYOFMONTH

func (s *FunctionNameBaseContext) DAYOFMONTH() antlr.TerminalNode

func (*FunctionNameBaseContext) DAYOFWEEK

func (*FunctionNameBaseContext) DAYOFYEAR

func (*FunctionNameBaseContext) DECODE

func (*FunctionNameBaseContext) DEGREES

func (*FunctionNameBaseContext) DENSE_RANK

func (s *FunctionNameBaseContext) DENSE_RANK() antlr.TerminalNode

func (*FunctionNameBaseContext) DES_DECRYPT

func (s *FunctionNameBaseContext) DES_DECRYPT() antlr.TerminalNode

func (*FunctionNameBaseContext) DES_ENCRYPT

func (s *FunctionNameBaseContext) DES_ENCRYPT() antlr.TerminalNode

func (*FunctionNameBaseContext) DIMENSION

func (*FunctionNameBaseContext) DISJOINT

func (*FunctionNameBaseContext) DOT_PRODUCT_DISTANCE

func (s *FunctionNameBaseContext) DOT_PRODUCT_DISTANCE() antlr.TerminalNode

func (*FunctionNameBaseContext) ELT

func (*FunctionNameBaseContext) ENCODE

func (*FunctionNameBaseContext) ENCRYPT

func (*FunctionNameBaseContext) ENDPOINT

func (*FunctionNameBaseContext) ENVELOPE

func (*FunctionNameBaseContext) EQUALS

func (*FunctionNameBaseContext) EUCLIDEAN_DISTANCE

func (s *FunctionNameBaseContext) EUCLIDEAN_DISTANCE() antlr.TerminalNode

func (*FunctionNameBaseContext) EUCLIDEAN_SQUARE_DISTANCE

func (s *FunctionNameBaseContext) EUCLIDEAN_SQUARE_DISTANCE() antlr.TerminalNode

func (*FunctionNameBaseContext) EXP

func (*FunctionNameBaseContext) EXPORT_SET

func (s *FunctionNameBaseContext) EXPORT_SET() antlr.TerminalNode

func (*FunctionNameBaseContext) EXTERIORRING

func (s *FunctionNameBaseContext) EXTERIORRING() antlr.TerminalNode

func (*FunctionNameBaseContext) EXTRACTVALUE

func (s *FunctionNameBaseContext) EXTRACTVALUE() antlr.TerminalNode

func (*FunctionNameBaseContext) EnterRule

func (s *FunctionNameBaseContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionNameBaseContext) ExitRule

func (s *FunctionNameBaseContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionNameBaseContext) FIELD

func (*FunctionNameBaseContext) FIND_IN_SET

func (s *FunctionNameBaseContext) FIND_IN_SET() antlr.TerminalNode

func (*FunctionNameBaseContext) FIRST_VALUE

func (s *FunctionNameBaseContext) FIRST_VALUE() antlr.TerminalNode

func (*FunctionNameBaseContext) FLOOR

func (*FunctionNameBaseContext) FORMAT

func (*FunctionNameBaseContext) FOUND_ROWS

func (s *FunctionNameBaseContext) FOUND_ROWS() antlr.TerminalNode

func (*FunctionNameBaseContext) FROM_BASE64

func (s *FunctionNameBaseContext) FROM_BASE64() antlr.TerminalNode

func (*FunctionNameBaseContext) FROM_DAYS

func (*FunctionNameBaseContext) FROM_UNIXTIME

func (s *FunctionNameBaseContext) FROM_UNIXTIME() antlr.TerminalNode

func (*FunctionNameBaseContext) GEOMCOLLFROMTEXT

func (s *FunctionNameBaseContext) GEOMCOLLFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) GEOMCOLLFROMWKB

func (s *FunctionNameBaseContext) GEOMCOLLFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) GEOMETRYCOLLECTION

func (s *FunctionNameBaseContext) GEOMETRYCOLLECTION() antlr.TerminalNode

func (*FunctionNameBaseContext) GEOMETRYCOLLECTIONFROMTEXT

func (s *FunctionNameBaseContext) GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) GEOMETRYCOLLECTIONFROMWKB

func (s *FunctionNameBaseContext) GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) GEOMETRYFROMTEXT

func (s *FunctionNameBaseContext) GEOMETRYFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) GEOMETRYFROMWKB

func (s *FunctionNameBaseContext) GEOMETRYFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) GEOMETRYN

func (*FunctionNameBaseContext) GEOMETRYTYPE

func (s *FunctionNameBaseContext) GEOMETRYTYPE() antlr.TerminalNode

func (*FunctionNameBaseContext) GEOMFROMTEXT

func (s *FunctionNameBaseContext) GEOMFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) GEOMFROMWKB

func (s *FunctionNameBaseContext) GEOMFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) GET_FORMAT

func (s *FunctionNameBaseContext) GET_FORMAT() antlr.TerminalNode

func (*FunctionNameBaseContext) GET_LOCK

func (*FunctionNameBaseContext) GLENGTH

func (*FunctionNameBaseContext) GREATEST

func (*FunctionNameBaseContext) GTID_SUBSET

func (s *FunctionNameBaseContext) GTID_SUBSET() antlr.TerminalNode

func (*FunctionNameBaseContext) GTID_SUBTRACT

func (s *FunctionNameBaseContext) GTID_SUBTRACT() antlr.TerminalNode

func (*FunctionNameBaseContext) GetParser

func (s *FunctionNameBaseContext) GetParser() antlr.Parser

func (*FunctionNameBaseContext) GetRuleContext

func (s *FunctionNameBaseContext) GetRuleContext() antlr.RuleContext

func (*FunctionNameBaseContext) HEX

func (*FunctionNameBaseContext) HOUR

func (*FunctionNameBaseContext) IFNULL

func (*FunctionNameBaseContext) INET6_ATON

func (s *FunctionNameBaseContext) INET6_ATON() antlr.TerminalNode

func (*FunctionNameBaseContext) INET6_NTOA

func (s *FunctionNameBaseContext) INET6_NTOA() antlr.TerminalNode

func (*FunctionNameBaseContext) INET_ATON

func (*FunctionNameBaseContext) INET_NTOA

func (*FunctionNameBaseContext) INSTR

func (*FunctionNameBaseContext) INTERIORRINGN

func (s *FunctionNameBaseContext) INTERIORRINGN() antlr.TerminalNode

func (*FunctionNameBaseContext) INTERSECTS

func (s *FunctionNameBaseContext) INTERSECTS() antlr.TerminalNode

func (*FunctionNameBaseContext) INVISIBLE

func (*FunctionNameBaseContext) ISCLOSED

func (*FunctionNameBaseContext) ISEMPTY

func (*FunctionNameBaseContext) ISNULL

func (*FunctionNameBaseContext) ISSIMPLE

func (*FunctionNameBaseContext) IS_FREE_LOCK

func (s *FunctionNameBaseContext) IS_FREE_LOCK() antlr.TerminalNode

func (*FunctionNameBaseContext) IS_IPV4

func (*FunctionNameBaseContext) IS_IPV4_COMPAT

func (s *FunctionNameBaseContext) IS_IPV4_COMPAT() antlr.TerminalNode

func (*FunctionNameBaseContext) IS_IPV4_MAPPED

func (s *FunctionNameBaseContext) IS_IPV4_MAPPED() antlr.TerminalNode

func (*FunctionNameBaseContext) IS_IPV6

func (*FunctionNameBaseContext) IS_USED_LOCK

func (s *FunctionNameBaseContext) IS_USED_LOCK() antlr.TerminalNode

func (*FunctionNameBaseContext) IsFunctionNameBaseContext

func (*FunctionNameBaseContext) IsFunctionNameBaseContext()

func (*FunctionNameBaseContext) JSON_ARRAY

func (s *FunctionNameBaseContext) JSON_ARRAY() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_ARRAYAGG

func (s *FunctionNameBaseContext) JSON_ARRAYAGG() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_ARRAY_APPEND

func (s *FunctionNameBaseContext) JSON_ARRAY_APPEND() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_ARRAY_INSERT

func (s *FunctionNameBaseContext) JSON_ARRAY_INSERT() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_CONTAINS

func (s *FunctionNameBaseContext) JSON_CONTAINS() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_CONTAINS_PATH

func (s *FunctionNameBaseContext) JSON_CONTAINS_PATH() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_DEPTH

func (s *FunctionNameBaseContext) JSON_DEPTH() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_EXTRACT

func (s *FunctionNameBaseContext) JSON_EXTRACT() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_INSERT

func (s *FunctionNameBaseContext) JSON_INSERT() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_KEYS

func (*FunctionNameBaseContext) JSON_LENGTH

func (s *FunctionNameBaseContext) JSON_LENGTH() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_MERGE

func (s *FunctionNameBaseContext) JSON_MERGE() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_MERGE_PATCH

func (s *FunctionNameBaseContext) JSON_MERGE_PATCH() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_MERGE_PRESERVE

func (s *FunctionNameBaseContext) JSON_MERGE_PRESERVE() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_OBJECT

func (s *FunctionNameBaseContext) JSON_OBJECT() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_OBJECTAGG

func (s *FunctionNameBaseContext) JSON_OBJECTAGG() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_OVERLAPS

func (s *FunctionNameBaseContext) JSON_OVERLAPS() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_PRETTY

func (s *FunctionNameBaseContext) JSON_PRETTY() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_QUOTE

func (s *FunctionNameBaseContext) JSON_QUOTE() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_REMOVE

func (s *FunctionNameBaseContext) JSON_REMOVE() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_REPLACE

func (s *FunctionNameBaseContext) JSON_REPLACE() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_SCHEMA_VALID

func (s *FunctionNameBaseContext) JSON_SCHEMA_VALID() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_SCHEMA_VALIDATION_REPORT

func (s *FunctionNameBaseContext) JSON_SCHEMA_VALIDATION_REPORT() antlr.TerminalNode
func (s *FunctionNameBaseContext) JSON_SEARCH() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_SET

func (*FunctionNameBaseContext) JSON_STORAGE_FREE

func (s *FunctionNameBaseContext) JSON_STORAGE_FREE() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_STORAGE_SIZE

func (s *FunctionNameBaseContext) JSON_STORAGE_SIZE() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_TABLE

func (s *FunctionNameBaseContext) JSON_TABLE() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_TYPE

func (*FunctionNameBaseContext) JSON_UNQUOTE

func (s *FunctionNameBaseContext) JSON_UNQUOTE() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_VALID

func (s *FunctionNameBaseContext) JSON_VALID() antlr.TerminalNode

func (*FunctionNameBaseContext) JSON_VALUE

func (s *FunctionNameBaseContext) JSON_VALUE() antlr.TerminalNode

func (*FunctionNameBaseContext) LAG

func (*FunctionNameBaseContext) LAST_INSERT_ID

func (s *FunctionNameBaseContext) LAST_INSERT_ID() antlr.TerminalNode

func (*FunctionNameBaseContext) LAST_VALUE

func (s *FunctionNameBaseContext) LAST_VALUE() antlr.TerminalNode

func (*FunctionNameBaseContext) LCASE

func (*FunctionNameBaseContext) LEAD

func (*FunctionNameBaseContext) LEAST

func (*FunctionNameBaseContext) LEN

func (*FunctionNameBaseContext) LENGTH

func (*FunctionNameBaseContext) LINEFROMTEXT

func (s *FunctionNameBaseContext) LINEFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) LINEFROMWKB

func (s *FunctionNameBaseContext) LINEFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) LINESTRING

func (s *FunctionNameBaseContext) LINESTRING() antlr.TerminalNode

func (*FunctionNameBaseContext) LINESTRINGFROMTEXT

func (s *FunctionNameBaseContext) LINESTRINGFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) LINESTRINGFROMWKB

func (s *FunctionNameBaseContext) LINESTRINGFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) LN

func (*FunctionNameBaseContext) LOAD_FILE

func (*FunctionNameBaseContext) LOCATE

func (*FunctionNameBaseContext) LOG

func (*FunctionNameBaseContext) LOG2

func (*FunctionNameBaseContext) LOG10

func (*FunctionNameBaseContext) LOWER

func (*FunctionNameBaseContext) LPAD

func (*FunctionNameBaseContext) LTRIM

func (*FunctionNameBaseContext) MAKEDATE

func (*FunctionNameBaseContext) MAKETIME

func (*FunctionNameBaseContext) MAKE_SET

func (*FunctionNameBaseContext) MASTER_POS_WAIT

func (s *FunctionNameBaseContext) MASTER_POS_WAIT() antlr.TerminalNode

func (*FunctionNameBaseContext) MBRCONTAINS

func (s *FunctionNameBaseContext) MBRCONTAINS() antlr.TerminalNode

func (*FunctionNameBaseContext) MBRDISJOINT

func (s *FunctionNameBaseContext) MBRDISJOINT() antlr.TerminalNode

func (*FunctionNameBaseContext) MBREQUAL

func (*FunctionNameBaseContext) MBRINTERSECTS

func (s *FunctionNameBaseContext) MBRINTERSECTS() antlr.TerminalNode

func (*FunctionNameBaseContext) MBROVERLAPS

func (s *FunctionNameBaseContext) MBROVERLAPS() antlr.TerminalNode

func (*FunctionNameBaseContext) MBRTOUCHES

func (s *FunctionNameBaseContext) MBRTOUCHES() antlr.TerminalNode

func (*FunctionNameBaseContext) MBRWITHIN

func (*FunctionNameBaseContext) MD5

func (*FunctionNameBaseContext) MICROSECOND

func (s *FunctionNameBaseContext) MICROSECOND() antlr.TerminalNode

func (*FunctionNameBaseContext) MINUTE

func (*FunctionNameBaseContext) MLINEFROMTEXT

func (s *FunctionNameBaseContext) MLINEFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) MLINEFROMWKB

func (s *FunctionNameBaseContext) MLINEFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) MOD

func (*FunctionNameBaseContext) MONTH

func (*FunctionNameBaseContext) MONTHNAME

func (*FunctionNameBaseContext) MPOINTFROMTEXT

func (s *FunctionNameBaseContext) MPOINTFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) MPOINTFROMWKB

func (s *FunctionNameBaseContext) MPOINTFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) MPOLYFROMTEXT

func (s *FunctionNameBaseContext) MPOLYFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) MPOLYFROMWKB

func (s *FunctionNameBaseContext) MPOLYFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) MULTILINESTRING

func (s *FunctionNameBaseContext) MULTILINESTRING() antlr.TerminalNode

func (*FunctionNameBaseContext) MULTILINESTRINGFROMTEXT

func (s *FunctionNameBaseContext) MULTILINESTRINGFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) MULTILINESTRINGFROMWKB

func (s *FunctionNameBaseContext) MULTILINESTRINGFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) MULTIPOINT

func (s *FunctionNameBaseContext) MULTIPOINT() antlr.TerminalNode

func (*FunctionNameBaseContext) MULTIPOINTFROMTEXT

func (s *FunctionNameBaseContext) MULTIPOINTFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) MULTIPOINTFROMWKB

func (s *FunctionNameBaseContext) MULTIPOINTFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) MULTIPOLYGON

func (s *FunctionNameBaseContext) MULTIPOLYGON() antlr.TerminalNode

func (*FunctionNameBaseContext) MULTIPOLYGONFROMTEXT

func (s *FunctionNameBaseContext) MULTIPOLYGONFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) MULTIPOLYGONFROMWKB

func (s *FunctionNameBaseContext) MULTIPOLYGONFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) NAME_CONST

func (s *FunctionNameBaseContext) NAME_CONST() antlr.TerminalNode

func (*FunctionNameBaseContext) NTH_VALUE

func (*FunctionNameBaseContext) NTILE

func (*FunctionNameBaseContext) NULLIF

func (*FunctionNameBaseContext) NUMGEOMETRIES

func (s *FunctionNameBaseContext) NUMGEOMETRIES() antlr.TerminalNode

func (*FunctionNameBaseContext) NUMINTERIORRINGS

func (s *FunctionNameBaseContext) NUMINTERIORRINGS() antlr.TerminalNode

func (*FunctionNameBaseContext) NUMPOINTS

func (*FunctionNameBaseContext) OCT

func (*FunctionNameBaseContext) OCTET_LENGTH

func (s *FunctionNameBaseContext) OCTET_LENGTH() antlr.TerminalNode

func (*FunctionNameBaseContext) ORD

func (*FunctionNameBaseContext) OVERLAPS

func (*FunctionNameBaseContext) PERCENT_RANK

func (s *FunctionNameBaseContext) PERCENT_RANK() antlr.TerminalNode

func (*FunctionNameBaseContext) PERIOD_ADD

func (s *FunctionNameBaseContext) PERIOD_ADD() antlr.TerminalNode

func (*FunctionNameBaseContext) PERIOD_DIFF

func (s *FunctionNameBaseContext) PERIOD_DIFF() antlr.TerminalNode

func (*FunctionNameBaseContext) PI

func (*FunctionNameBaseContext) POINT

func (*FunctionNameBaseContext) POINTFROMTEXT

func (s *FunctionNameBaseContext) POINTFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) POINTFROMWKB

func (s *FunctionNameBaseContext) POINTFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) POINTN

func (*FunctionNameBaseContext) POLYFROMTEXT

func (s *FunctionNameBaseContext) POLYFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) POLYFROMWKB

func (s *FunctionNameBaseContext) POLYFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) POLYGON

func (*FunctionNameBaseContext) POLYGONFROMTEXT

func (s *FunctionNameBaseContext) POLYGONFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) POLYGONFROMWKB

func (s *FunctionNameBaseContext) POLYGONFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) POSITION

func (*FunctionNameBaseContext) POW

func (*FunctionNameBaseContext) POWER

func (*FunctionNameBaseContext) QUARTER

func (*FunctionNameBaseContext) QUOTE

func (*FunctionNameBaseContext) RADIANS

func (*FunctionNameBaseContext) RAND

func (*FunctionNameBaseContext) RANDOM_BYTES

func (s *FunctionNameBaseContext) RANDOM_BYTES() antlr.TerminalNode

func (*FunctionNameBaseContext) RANK

func (*FunctionNameBaseContext) RELEASE_LOCK

func (s *FunctionNameBaseContext) RELEASE_LOCK() antlr.TerminalNode

func (*FunctionNameBaseContext) REVERSE

func (*FunctionNameBaseContext) ROUND

func (*FunctionNameBaseContext) ROW_COUNT

func (*FunctionNameBaseContext) ROW_NUMBER

func (s *FunctionNameBaseContext) ROW_NUMBER() antlr.TerminalNode

func (*FunctionNameBaseContext) RPAD

func (*FunctionNameBaseContext) RTRIM

func (*FunctionNameBaseContext) SCHEMA

func (*FunctionNameBaseContext) SECOND

func (*FunctionNameBaseContext) SEC_TO_TIME

func (s *FunctionNameBaseContext) SEC_TO_TIME() antlr.TerminalNode

func (*FunctionNameBaseContext) SESSION_USER

func (s *FunctionNameBaseContext) SESSION_USER() antlr.TerminalNode

func (*FunctionNameBaseContext) SESSION_VARIABLES_ADMIN

func (s *FunctionNameBaseContext) SESSION_VARIABLES_ADMIN() antlr.TerminalNode

func (*FunctionNameBaseContext) SHA

func (*FunctionNameBaseContext) SHA1

func (*FunctionNameBaseContext) SHA2

func (*FunctionNameBaseContext) SIGN

func (*FunctionNameBaseContext) SIN

func (*FunctionNameBaseContext) SLEEP

func (*FunctionNameBaseContext) SOUNDEX

func (*FunctionNameBaseContext) SQL_THREAD_WAIT_AFTER_GTIDS

func (s *FunctionNameBaseContext) SQL_THREAD_WAIT_AFTER_GTIDS() antlr.TerminalNode

func (*FunctionNameBaseContext) SQRT

func (*FunctionNameBaseContext) SRID

func (*FunctionNameBaseContext) STARTPOINT

func (s *FunctionNameBaseContext) STARTPOINT() antlr.TerminalNode

func (*FunctionNameBaseContext) STRCMP

func (*FunctionNameBaseContext) STR_TO_DATE

func (s *FunctionNameBaseContext) STR_TO_DATE() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_AREA

func (*FunctionNameBaseContext) ST_ASBINARY

func (s *FunctionNameBaseContext) ST_ASBINARY() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_ASTEXT

func (*FunctionNameBaseContext) ST_ASWKB

func (*FunctionNameBaseContext) ST_ASWKT

func (*FunctionNameBaseContext) ST_BUFFER

func (*FunctionNameBaseContext) ST_CENTROID

func (s *FunctionNameBaseContext) ST_CENTROID() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_CONTAINS

func (s *FunctionNameBaseContext) ST_CONTAINS() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_CROSSES

func (s *FunctionNameBaseContext) ST_CROSSES() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_DIFFERENCE

func (s *FunctionNameBaseContext) ST_DIFFERENCE() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_DIMENSION

func (s *FunctionNameBaseContext) ST_DIMENSION() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_DISJOINT

func (s *FunctionNameBaseContext) ST_DISJOINT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_DISTANCE

func (s *FunctionNameBaseContext) ST_DISTANCE() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_ENDPOINT

func (s *FunctionNameBaseContext) ST_ENDPOINT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_ENVELOPE

func (s *FunctionNameBaseContext) ST_ENVELOPE() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_EQUALS

func (*FunctionNameBaseContext) ST_EXTERIORRING

func (s *FunctionNameBaseContext) ST_EXTERIORRING() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMCOLLFROMTEXT

func (s *FunctionNameBaseContext) ST_GEOMCOLLFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMCOLLFROMTXT

func (s *FunctionNameBaseContext) ST_GEOMCOLLFROMTXT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMCOLLFROMWKB

func (s *FunctionNameBaseContext) ST_GEOMCOLLFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMETRYCOLLECTIONFROMTEXT

func (s *FunctionNameBaseContext) ST_GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMETRYCOLLECTIONFROMWKB

func (s *FunctionNameBaseContext) ST_GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMETRYFROMTEXT

func (s *FunctionNameBaseContext) ST_GEOMETRYFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMETRYFROMWKB

func (s *FunctionNameBaseContext) ST_GEOMETRYFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMETRYN

func (s *FunctionNameBaseContext) ST_GEOMETRYN() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMETRYTYPE

func (s *FunctionNameBaseContext) ST_GEOMETRYTYPE() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMFROMTEXT

func (s *FunctionNameBaseContext) ST_GEOMFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_GEOMFROMWKB

func (s *FunctionNameBaseContext) ST_GEOMFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_INTERIORRINGN

func (s *FunctionNameBaseContext) ST_INTERIORRINGN() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_INTERSECTION

func (s *FunctionNameBaseContext) ST_INTERSECTION() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_INTERSECTS

func (s *FunctionNameBaseContext) ST_INTERSECTS() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_ISCLOSED

func (s *FunctionNameBaseContext) ST_ISCLOSED() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_ISEMPTY

func (s *FunctionNameBaseContext) ST_ISEMPTY() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_ISSIMPLE

func (s *FunctionNameBaseContext) ST_ISSIMPLE() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_LINEFROMTEXT

func (s *FunctionNameBaseContext) ST_LINEFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_LINEFROMWKB

func (s *FunctionNameBaseContext) ST_LINEFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_LINESTRINGFROMTEXT

func (s *FunctionNameBaseContext) ST_LINESTRINGFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_LINESTRINGFROMWKB

func (s *FunctionNameBaseContext) ST_LINESTRINGFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_NUMGEOMETRIES

func (s *FunctionNameBaseContext) ST_NUMGEOMETRIES() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_NUMINTERIORRING

func (s *FunctionNameBaseContext) ST_NUMINTERIORRING() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_NUMINTERIORRINGS

func (s *FunctionNameBaseContext) ST_NUMINTERIORRINGS() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_NUMPOINTS

func (s *FunctionNameBaseContext) ST_NUMPOINTS() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_OVERLAPS

func (s *FunctionNameBaseContext) ST_OVERLAPS() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_POINTFROMTEXT

func (s *FunctionNameBaseContext) ST_POINTFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_POINTFROMWKB

func (s *FunctionNameBaseContext) ST_POINTFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_POINTN

func (*FunctionNameBaseContext) ST_POLYFROMTEXT

func (s *FunctionNameBaseContext) ST_POLYFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_POLYFROMWKB

func (s *FunctionNameBaseContext) ST_POLYFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_POLYGONFROMTEXT

func (s *FunctionNameBaseContext) ST_POLYGONFROMTEXT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_POLYGONFROMWKB

func (s *FunctionNameBaseContext) ST_POLYGONFROMWKB() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_SRID

func (*FunctionNameBaseContext) ST_STARTPOINT

func (s *FunctionNameBaseContext) ST_STARTPOINT() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_SYMDIFFERENCE

func (s *FunctionNameBaseContext) ST_SYMDIFFERENCE() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_TOUCHES

func (s *FunctionNameBaseContext) ST_TOUCHES() antlr.TerminalNode

func (*FunctionNameBaseContext) ST_UNION

func (*FunctionNameBaseContext) ST_WITHIN

func (*FunctionNameBaseContext) ST_X

func (*FunctionNameBaseContext) ST_Y

func (*FunctionNameBaseContext) SUBDATE

func (*FunctionNameBaseContext) SUBSTRING_INDEX

func (s *FunctionNameBaseContext) SUBSTRING_INDEX() antlr.TerminalNode

func (*FunctionNameBaseContext) SUBTIME

func (*FunctionNameBaseContext) SYSTEM_USER

func (s *FunctionNameBaseContext) SYSTEM_USER() antlr.TerminalNode

func (*FunctionNameBaseContext) TAN

func (*FunctionNameBaseContext) TIME

func (*FunctionNameBaseContext) TIMEDIFF

func (*FunctionNameBaseContext) TIMESTAMP

func (*FunctionNameBaseContext) TIMESTAMPADD

func (s *FunctionNameBaseContext) TIMESTAMPADD() antlr.TerminalNode

func (*FunctionNameBaseContext) TIMESTAMPDIFF

func (s *FunctionNameBaseContext) TIMESTAMPDIFF() antlr.TerminalNode

func (*FunctionNameBaseContext) TIME_FORMAT

func (s *FunctionNameBaseContext) TIME_FORMAT() antlr.TerminalNode

func (*FunctionNameBaseContext) TIME_TO_SEC

func (s *FunctionNameBaseContext) TIME_TO_SEC() antlr.TerminalNode

func (*FunctionNameBaseContext) TOUCHES

func (*FunctionNameBaseContext) TO_BASE64

func (*FunctionNameBaseContext) TO_DAYS

func (*FunctionNameBaseContext) TO_SECONDS

func (s *FunctionNameBaseContext) TO_SECONDS() antlr.TerminalNode

func (*FunctionNameBaseContext) ToStringTree

func (s *FunctionNameBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*FunctionNameBaseContext) UCASE

func (*FunctionNameBaseContext) UNCOMPRESS

func (s *FunctionNameBaseContext) UNCOMPRESS() antlr.TerminalNode

func (*FunctionNameBaseContext) UNCOMPRESSED_LENGTH

func (s *FunctionNameBaseContext) UNCOMPRESSED_LENGTH() antlr.TerminalNode

func (*FunctionNameBaseContext) UNHEX

func (*FunctionNameBaseContext) UNIX_TIMESTAMP

func (s *FunctionNameBaseContext) UNIX_TIMESTAMP() antlr.TerminalNode

func (*FunctionNameBaseContext) UPDATEXML

func (*FunctionNameBaseContext) UPPER

func (*FunctionNameBaseContext) VALIDATE_PASSWORD_STRENGTH

func (s *FunctionNameBaseContext) VALIDATE_PASSWORD_STRENGTH() antlr.TerminalNode

func (*FunctionNameBaseContext) VERSION

func (*FunctionNameBaseContext) VISIBLE

func (*FunctionNameBaseContext) WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS

func (s *FunctionNameBaseContext) WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() antlr.TerminalNode

func (*FunctionNameBaseContext) WEEK

func (*FunctionNameBaseContext) WEEKDAY

func (*FunctionNameBaseContext) WEEKOFYEAR

func (s *FunctionNameBaseContext) WEEKOFYEAR() antlr.TerminalNode

func (*FunctionNameBaseContext) WEIGHT_STRING

func (s *FunctionNameBaseContext) WEIGHT_STRING() antlr.TerminalNode

func (*FunctionNameBaseContext) WITHIN

func (*FunctionNameBaseContext) X_FUNCTION

func (s *FunctionNameBaseContext) X_FUNCTION() antlr.TerminalNode

func (*FunctionNameBaseContext) YEAR

func (*FunctionNameBaseContext) YEARWEEK

func (*FunctionNameBaseContext) Y_FUNCTION

func (s *FunctionNameBaseContext) Y_FUNCTION() antlr.TerminalNode

type FunctionNameKeywordContext

type FunctionNameKeywordContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionNameKeywordContext

func NewEmptyFunctionNameKeywordContext() *FunctionNameKeywordContext

func NewFunctionNameKeywordContext

func NewFunctionNameKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionNameKeywordContext

func (*FunctionNameKeywordContext) Accept

func (s *FunctionNameKeywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionNameKeywordContext) EnterRule

func (s *FunctionNameKeywordContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionNameKeywordContext) ExitRule

func (s *FunctionNameKeywordContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionNameKeywordContext) GetParser

func (s *FunctionNameKeywordContext) GetParser() antlr.Parser

func (*FunctionNameKeywordContext) GetRuleContext

func (s *FunctionNameKeywordContext) GetRuleContext() antlr.RuleContext

func (*FunctionNameKeywordContext) IsFunctionNameKeywordContext

func (*FunctionNameKeywordContext) IsFunctionNameKeywordContext()

func (*FunctionNameKeywordContext) LEFT

func (*FunctionNameKeywordContext) RIGHT

func (*FunctionNameKeywordContext) ToStringTree

func (s *FunctionNameKeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FunctionSpecificationContext

type FunctionSpecificationContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionSpecificationContext

func NewEmptyFunctionSpecificationContext() *FunctionSpecificationContext

func NewFunctionSpecificationContext

func NewFunctionSpecificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionSpecificationContext

func (*FunctionSpecificationContext) Accept

func (s *FunctionSpecificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionSpecificationContext) DispatchClause

func (*FunctionSpecificationContext) EnterRule

func (s *FunctionSpecificationContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionSpecificationContext) ExitRule

func (*FunctionSpecificationContext) FUNCTION

func (*FunctionSpecificationContext) FullId

func (*FunctionSpecificationContext) GetParser

func (s *FunctionSpecificationContext) GetParser() antlr.Parser

func (*FunctionSpecificationContext) GetRuleContext

func (s *FunctionSpecificationContext) GetRuleContext() antlr.RuleContext

func (*FunctionSpecificationContext) GetSchemaQualifiedRoutineName

func (s *FunctionSpecificationContext) GetSchemaQualifiedRoutineName() IFullIdContext

func (*FunctionSpecificationContext) IsFunctionSpecificationContext

func (*FunctionSpecificationContext) IsFunctionSpecificationContext()

func (*FunctionSpecificationContext) ReturnsClause

func (*FunctionSpecificationContext) RoutineCharacteristics

func (*FunctionSpecificationContext) SetSchemaQualifiedRoutineName

func (s *FunctionSpecificationContext) SetSchemaQualifiedRoutineName(v IFullIdContext)

func (*FunctionSpecificationContext) SqlParameterDeclarationList

func (s *FunctionSpecificationContext) SqlParameterDeclarationList() ISqlParameterDeclarationListContext

func (*FunctionSpecificationContext) ToStringTree

func (s *FunctionSpecificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type GetFormatFunctionCallContext

type GetFormatFunctionCallContext struct {
	SpecificFunctionContext
	// contains filtered or unexported fields
}

func NewGetFormatFunctionCallContext

func NewGetFormatFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GetFormatFunctionCallContext

func (*GetFormatFunctionCallContext) Accept

func (s *GetFormatFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*GetFormatFunctionCallContext) COMMA

func (*GetFormatFunctionCallContext) DATE

func (*GetFormatFunctionCallContext) DATETIME

func (*GetFormatFunctionCallContext) EnterRule

func (s *GetFormatFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*GetFormatFunctionCallContext) ExitRule

func (*GetFormatFunctionCallContext) GET_FORMAT

func (*GetFormatFunctionCallContext) GetDatetimeFormat

func (s *GetFormatFunctionCallContext) GetDatetimeFormat() antlr.Token

func (*GetFormatFunctionCallContext) GetRuleContext

func (s *GetFormatFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*GetFormatFunctionCallContext) LEFT_ROUND_BRACKET

func (s *GetFormatFunctionCallContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*GetFormatFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *GetFormatFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*GetFormatFunctionCallContext) SetDatetimeFormat

func (s *GetFormatFunctionCallContext) SetDatetimeFormat(v antlr.Token)

func (*GetFormatFunctionCallContext) StringLiteral

func (*GetFormatFunctionCallContext) TIME

type GroupByClauseContext

type GroupByClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyGroupByClauseContext

func NewEmptyGroupByClauseContext() *GroupByClauseContext

func NewGroupByClauseContext

func NewGroupByClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupByClauseContext

func (*GroupByClauseContext) Accept

func (s *GroupByClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*GroupByClauseContext) AllCOMMA

func (s *GroupByClauseContext) AllCOMMA() []antlr.TerminalNode

func (*GroupByClauseContext) AllGroupByItem

func (s *GroupByClauseContext) AllGroupByItem() []IGroupByItemContext

func (*GroupByClauseContext) BY

func (*GroupByClauseContext) COMMA

func (*GroupByClauseContext) EnterRule

func (s *GroupByClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*GroupByClauseContext) ExitRule

func (s *GroupByClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*GroupByClauseContext) GROUP

func (*GroupByClauseContext) GetParser

func (s *GroupByClauseContext) GetParser() antlr.Parser

func (*GroupByClauseContext) GetRuleContext

func (s *GroupByClauseContext) GetRuleContext() antlr.RuleContext

func (*GroupByClauseContext) GroupByItem

func (s *GroupByClauseContext) GroupByItem(i int) IGroupByItemContext

func (*GroupByClauseContext) IsGroupByClauseContext

func (*GroupByClauseContext) IsGroupByClauseContext()

func (*GroupByClauseContext) ToStringTree

func (s *GroupByClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type GroupByItemContext

type GroupByItemContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyGroupByItemContext

func NewEmptyGroupByItemContext() *GroupByItemContext

func NewGroupByItemContext

func NewGroupByItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupByItemContext

func (*GroupByItemContext) AS

func (*GroupByItemContext) ASC

func (*GroupByItemContext) Accept

func (s *GroupByItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*GroupByItemContext) DESC

func (*GroupByItemContext) EnterRule

func (s *GroupByItemContext) EnterRule(listener antlr.ParseTreeListener)

func (*GroupByItemContext) ExitRule

func (s *GroupByItemContext) ExitRule(listener antlr.ParseTreeListener)

func (*GroupByItemContext) Expression

func (s *GroupByItemContext) Expression() IExpressionContext

func (*GroupByItemContext) GetOrder

func (s *GroupByItemContext) GetOrder() antlr.Token

func (*GroupByItemContext) GetParser

func (s *GroupByItemContext) GetParser() antlr.Parser

func (*GroupByItemContext) GetRuleContext

func (s *GroupByItemContext) GetRuleContext() antlr.RuleContext

func (*GroupByItemContext) IsGroupByItemContext

func (*GroupByItemContext) IsGroupByItemContext()

func (*GroupByItemContext) SetOrder

func (s *GroupByItemContext) SetOrder(v antlr.Token)

func (*GroupByItemContext) ToStringTree

func (s *GroupByItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*GroupByItemContext) Uid

type HavingClauseContext

type HavingClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyHavingClauseContext

func NewEmptyHavingClauseContext() *HavingClauseContext

func NewHavingClauseContext

func NewHavingClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HavingClauseContext

func (*HavingClauseContext) Accept

func (s *HavingClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*HavingClauseContext) EnterRule

func (s *HavingClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*HavingClauseContext) ExitRule

func (s *HavingClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*HavingClauseContext) Expression

func (s *HavingClauseContext) Expression() IExpressionContext

func (*HavingClauseContext) GetHavingExpr

func (s *HavingClauseContext) GetHavingExpr() IExpressionContext

func (*HavingClauseContext) GetParser

func (s *HavingClauseContext) GetParser() antlr.Parser

func (*HavingClauseContext) GetRuleContext

func (s *HavingClauseContext) GetRuleContext() antlr.RuleContext

func (*HavingClauseContext) HAVING

func (*HavingClauseContext) IsHavingClauseContext

func (*HavingClauseContext) IsHavingClauseContext()

func (*HavingClauseContext) SetHavingExpr

func (s *HavingClauseContext) SetHavingExpr(v IExpressionContext)

func (*HavingClauseContext) ToStringTree

func (s *HavingClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type HelpStatementContext

type HelpStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyHelpStatementContext

func NewEmptyHelpStatementContext() *HelpStatementContext

func NewHelpStatementContext

func NewHelpStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HelpStatementContext

func (*HelpStatementContext) Accept

func (s *HelpStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*HelpStatementContext) EnterRule

func (s *HelpStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*HelpStatementContext) ExitRule

func (s *HelpStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*HelpStatementContext) GetParser

func (s *HelpStatementContext) GetParser() antlr.Parser

func (*HelpStatementContext) GetRuleContext

func (s *HelpStatementContext) GetRuleContext() antlr.RuleContext

func (*HelpStatementContext) HELP

func (*HelpStatementContext) IsHelpStatementContext

func (*HelpStatementContext) IsHelpStatementContext()

func (*HelpStatementContext) STRING_LITERAL

func (s *HelpStatementContext) STRING_LITERAL() antlr.TerminalNode

func (*HelpStatementContext) ToStringTree

func (s *HelpStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type HnswMetricContext

type HnswMetricContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyHnswMetricContext

func NewEmptyHnswMetricContext() *HnswMetricContext

func NewHnswMetricContext

func NewHnswMetricContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HnswMetricContext

func (*HnswMetricContext) Accept

func (s *HnswMetricContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*HnswMetricContext) COSINE_METRIC

func (s *HnswMetricContext) COSINE_METRIC() antlr.TerminalNode

func (*HnswMetricContext) DOT_PRODUCT_METRIC

func (s *HnswMetricContext) DOT_PRODUCT_METRIC() antlr.TerminalNode

func (*HnswMetricContext) EUCLIDEAN_METRIC

func (s *HnswMetricContext) EUCLIDEAN_METRIC() antlr.TerminalNode

func (*HnswMetricContext) EUCLIDEAN_SQUARE_METRIC

func (s *HnswMetricContext) EUCLIDEAN_SQUARE_METRIC() antlr.TerminalNode

func (*HnswMetricContext) EnterRule

func (s *HnswMetricContext) EnterRule(listener antlr.ParseTreeListener)

func (*HnswMetricContext) ExitRule

func (s *HnswMetricContext) ExitRule(listener antlr.ParseTreeListener)

func (*HnswMetricContext) GetParser

func (s *HnswMetricContext) GetParser() antlr.Parser

func (*HnswMetricContext) GetRuleContext

func (s *HnswMetricContext) GetRuleContext() antlr.RuleContext

func (*HnswMetricContext) IsHnswMetricContext

func (*HnswMetricContext) IsHnswMetricContext()

func (*HnswMetricContext) ToStringTree

func (s *HnswMetricContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IAdministrationStatementContext

type IAdministrationStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SetStatement() ISetStatementContext
	ShowStatement() IShowStatementContext
	KillStatement() IKillStatementContext
	ResetStatement() IResetStatementContext
	ExecuteContinuationStatement() IExecuteContinuationStatementContext
	CopyStatement() ICopyStatementContext

	// IsAdministrationStatementContext differentiates from other interfaces.
	IsAdministrationStatementContext()
}

IAdministrationStatementContext is an interface to support dynamic dispatch.

type IAggregateLimitClauseContext

type IAggregateLimitClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetLimit returns the limit rule contexts.
	GetLimit() IDecimalLiteralContext

	// SetLimit sets the limit rule contexts.
	SetLimit(IDecimalLiteralContext)

	// Getter signatures
	LIMIT() antlr.TerminalNode
	DecimalLiteral() IDecimalLiteralContext

	// IsAggregateLimitClauseContext differentiates from other interfaces.
	IsAggregateLimitClauseContext()
}

IAggregateLimitClauseContext is an interface to support dynamic dispatch.

type IAggregateWindowedFunctionContext

type IAggregateWindowedFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetFunctionName returns the functionName token.
	GetFunctionName() antlr.Token

	// GetAggregator returns the aggregator token.
	GetAggregator() antlr.Token

	// GetStarArg returns the starArg token.
	GetStarArg() antlr.Token

	// GetSeparator returns the separator token.
	GetSeparator() antlr.Token

	// SetFunctionName sets the functionName token.
	SetFunctionName(antlr.Token)

	// SetAggregator sets the aggregator token.
	SetAggregator(antlr.Token)

	// SetStarArg sets the starArg token.
	SetStarArg(antlr.Token)

	// SetSeparator sets the separator token.
	SetSeparator(antlr.Token)

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	FunctionArg() IFunctionArgContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AVG() antlr.TerminalNode
	MAX() antlr.TerminalNode
	MIN() antlr.TerminalNode
	SUM() antlr.TerminalNode
	MAX_EVER() antlr.TerminalNode
	MIN_EVER() antlr.TerminalNode
	OverClause() IOverClauseContext
	ALL() antlr.TerminalNode
	DISTINCT() antlr.TerminalNode
	BITMAP_CONSTRUCT_AGG() antlr.TerminalNode
	COUNT() antlr.TerminalNode
	FunctionArgs() IFunctionArgsContext
	STAR() antlr.TerminalNode
	BIT_AND() antlr.TerminalNode
	BIT_OR() antlr.TerminalNode
	BIT_XOR() antlr.TerminalNode
	STD() antlr.TerminalNode
	STDDEV() antlr.TerminalNode
	STDDEV_POP() antlr.TerminalNode
	STDDEV_SAMP() antlr.TerminalNode
	VAR_POP() antlr.TerminalNode
	VAR_SAMP() antlr.TerminalNode
	VARIANCE() antlr.TerminalNode
	ARRAY_AGG() antlr.TerminalNode
	NullTreatmentClause() INullTreatmentClauseContext
	OrderByClause() IOrderByClauseContext
	AggregateLimitClause() IAggregateLimitClauseContext
	GROUP_CONCAT() antlr.TerminalNode
	ORDER() antlr.TerminalNode
	BY() antlr.TerminalNode
	AllOrderByExpression() []IOrderByExpressionContext
	OrderByExpression(i int) IOrderByExpressionContext
	SEPARATOR() antlr.TerminalNode
	STRING_LITERAL() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsAggregateWindowedFunctionContext differentiates from other interfaces.
	IsAggregateWindowedFunctionContext()
}

IAggregateWindowedFunctionContext is an interface to support dynamic dispatch.

type IArrayConstructorContext

type IArrayConstructorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_SQUARE_BRACKET() antlr.TerminalNode
	RIGHT_SQUARE_BRACKET() antlr.TerminalNode
	Expressions() IExpressionsContext

	// IsArrayConstructorContext differentiates from other interfaces.
	IsArrayConstructorContext()
}

IArrayConstructorContext is an interface to support dynamic dispatch.

type IAssignmentFieldContext

type IAssignmentFieldContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Uid() IUidContext
	LOCAL_ID() antlr.TerminalNode

	// IsAssignmentFieldContext differentiates from other interfaces.
	IsAssignmentFieldContext()
}

IAssignmentFieldContext is an interface to support dynamic dispatch.

type IBitOperatorContext

type IBitOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllLESS_SYMBOL() []antlr.TerminalNode
	LESS_SYMBOL(i int) antlr.TerminalNode
	AllGREATER_SYMBOL() []antlr.TerminalNode
	GREATER_SYMBOL(i int) antlr.TerminalNode
	BIT_AND_OP() antlr.TerminalNode
	BIT_XOR_OP() antlr.TerminalNode
	BIT_OR_OP() antlr.TerminalNode

	// IsBitOperatorContext differentiates from other interfaces.
	IsBitOperatorContext()
}

IBitOperatorContext is an interface to support dynamic dispatch.

type IBooleanLiteralContext

type IBooleanLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TRUE() antlr.TerminalNode
	FALSE() antlr.TerminalNode

	// IsBooleanLiteralContext differentiates from other interfaces.
	IsBooleanLiteralContext()
}

IBooleanLiteralContext is an interface to support dynamic dispatch.

type IBytesLiteralContext

type IBytesLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	HEXADECIMAL_LITERAL() antlr.TerminalNode
	BASE64_LITERAL() antlr.TerminalNode

	// IsBytesLiteralContext differentiates from other interfaces.
	IsBytesLiteralContext()
}

IBytesLiteralContext is an interface to support dynamic dispatch.

type ICaseFuncAlternativeContext

type ICaseFuncAlternativeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCondition returns the condition rule contexts.
	GetCondition() IFunctionArgContext

	// GetConsequent returns the consequent rule contexts.
	GetConsequent() IFunctionArgContext

	// SetCondition sets the condition rule contexts.
	SetCondition(IFunctionArgContext)

	// SetConsequent sets the consequent rule contexts.
	SetConsequent(IFunctionArgContext)

	// Getter signatures
	WHEN() antlr.TerminalNode
	THEN() antlr.TerminalNode
	AllFunctionArg() []IFunctionArgContext
	FunctionArg(i int) IFunctionArgContext

	// IsCaseFuncAlternativeContext differentiates from other interfaces.
	IsCaseFuncAlternativeContext()
}

ICaseFuncAlternativeContext is an interface to support dynamic dispatch.

type ICharSetContext

type ICharSetContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CHARACTER() antlr.TerminalNode
	SET() antlr.TerminalNode
	CHARSET() antlr.TerminalNode
	CHAR() antlr.TerminalNode

	// IsCharSetContext differentiates from other interfaces.
	IsCharSetContext()
}

ICharSetContext is an interface to support dynamic dispatch.

type ICharsetNameBaseContext

type ICharsetNameBaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ARMSCII8() antlr.TerminalNode
	ASCII() antlr.TerminalNode
	BIG5() antlr.TerminalNode
	BINARY() antlr.TerminalNode
	CP1250() antlr.TerminalNode
	CP1251() antlr.TerminalNode
	CP1256() antlr.TerminalNode
	CP1257() antlr.TerminalNode
	CP850() antlr.TerminalNode
	CP852() antlr.TerminalNode
	CP866() antlr.TerminalNode
	CP932() antlr.TerminalNode
	DEC8() antlr.TerminalNode
	EUCJPMS() antlr.TerminalNode
	EUCKR() antlr.TerminalNode
	GB18030() antlr.TerminalNode
	GB2312() antlr.TerminalNode
	GBK() antlr.TerminalNode
	GEOSTD8() antlr.TerminalNode
	GREEK() antlr.TerminalNode
	HEBREW() antlr.TerminalNode
	HP8() antlr.TerminalNode
	KEYBCS2() antlr.TerminalNode
	KOI8R() antlr.TerminalNode
	KOI8U() antlr.TerminalNode
	LATIN1() antlr.TerminalNode
	LATIN2() antlr.TerminalNode
	LATIN5() antlr.TerminalNode
	LATIN7() antlr.TerminalNode
	MACCE() antlr.TerminalNode
	MACROMAN() antlr.TerminalNode
	SJIS() antlr.TerminalNode
	SWE7() antlr.TerminalNode
	TIS620() antlr.TerminalNode
	UCS2() antlr.TerminalNode
	UJIS() antlr.TerminalNode
	UTF16() antlr.TerminalNode
	UTF16LE() antlr.TerminalNode
	UTF32() antlr.TerminalNode
	UTF8() antlr.TerminalNode
	UTF8MB3() antlr.TerminalNode
	UTF8MB4() antlr.TerminalNode

	// IsCharsetNameBaseContext differentiates from other interfaces.
	IsCharsetNameBaseContext()
}

ICharsetNameBaseContext is an interface to support dynamic dispatch.

type ICharsetNameContext

type ICharsetNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BINARY() antlr.TerminalNode
	CharsetNameBase() ICharsetNameBaseContext
	STRING_LITERAL() antlr.TerminalNode

	// IsCharsetNameContext differentiates from other interfaces.
	IsCharsetNameContext()
}

ICharsetNameContext is an interface to support dynamic dispatch.

type ICollationNameContext

type ICollationNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Uid() IUidContext
	STRING_LITERAL() antlr.TerminalNode

	// IsCollationNameContext differentiates from other interfaces.
	IsCollationNameContext()
}

ICollationNameContext is an interface to support dynamic dispatch.

type ICollectionOptionsContext

type ICollectionOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllSTRING_LITERAL() []antlr.TerminalNode
	STRING_LITERAL(i int) antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsCollectionOptionsContext differentiates from other interfaces.
	IsCollectionOptionsContext()
}

ICollectionOptionsContext is an interface to support dynamic dispatch.

type IColumnConstraintContext

type IColumnConstraintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsColumnConstraintContext differentiates from other interfaces.
	IsColumnConstraintContext()
}

IColumnConstraintContext is an interface to support dynamic dispatch.

type IColumnDefinitionContext

type IColumnDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetColName returns the colName rule contexts.
	GetColName() IUidContext

	// SetColName sets the colName rule contexts.
	SetColName(IUidContext)

	// Getter signatures
	ColumnType() IColumnTypeContext
	Uid() IUidContext
	ARRAY() antlr.TerminalNode
	ColumnConstraint() IColumnConstraintContext

	// IsColumnDefinitionContext differentiates from other interfaces.
	IsColumnDefinitionContext()
}

IColumnDefinitionContext is an interface to support dynamic dispatch.

type IColumnTypeContext

type IColumnTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCustomType returns the customType rule contexts.
	GetCustomType() IUidContext

	// SetCustomType sets the customType rule contexts.
	SetCustomType(IUidContext)

	// Getter signatures
	PrimitiveType() IPrimitiveTypeContext
	Uid() IUidContext

	// IsColumnTypeContext differentiates from other interfaces.
	IsColumnTypeContext()
}

IColumnTypeContext is an interface to support dynamic dispatch.

type ICommitStatementContext

type ICommitStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	COMMIT() antlr.TerminalNode

	// IsCommitStatementContext differentiates from other interfaces.
	IsCommitStatementContext()
}

ICommitStatementContext is an interface to support dynamic dispatch.

type IComparisonOperatorContext

type IComparisonOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EQUAL_SYMBOL() antlr.TerminalNode
	GREATER_SYMBOL() antlr.TerminalNode
	LESS_SYMBOL() antlr.TerminalNode
	EXCLAMATION_SYMBOL() antlr.TerminalNode
	IS() antlr.TerminalNode
	DISTINCT() antlr.TerminalNode
	FROM() antlr.TerminalNode
	NOT() antlr.TerminalNode

	// IsComparisonOperatorContext differentiates from other interfaces.
	IsComparisonOperatorContext()
}

IComparisonOperatorContext is an interface to support dynamic dispatch.

type IConstantContext

type IConstantContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsConstantContext differentiates from other interfaces.
	IsConstantContext()
}

IConstantContext is an interface to support dynamic dispatch.

type IContinuationAtomContext

type IContinuationAtomContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BytesLiteral() IBytesLiteralContext
	PreparedStatementParameter() IPreparedStatementParameterContext

	// IsContinuationAtomContext differentiates from other interfaces.
	IsContinuationAtomContext()
}

IContinuationAtomContext is an interface to support dynamic dispatch.

type IConvertedDataTypeContext

type IConvertedDataTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetTypeName returns the typeName rule contexts.
	GetTypeName() IPrimitiveTypeContext

	// SetTypeName sets the typeName rule contexts.
	SetTypeName(IPrimitiveTypeContext)

	// Getter signatures
	PrimitiveType() IPrimitiveTypeContext
	ARRAY() antlr.TerminalNode

	// IsConvertedDataTypeContext differentiates from other interfaces.
	IsConvertedDataTypeContext()
}

IConvertedDataTypeContext is an interface to support dynamic dispatch.

type ICopyStatementContext

type ICopyStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsCopyStatementContext differentiates from other interfaces.
	IsCopyStatementContext()
}

ICopyStatementContext is an interface to support dynamic dispatch.

type ICreateStatementContext

type ICreateStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsCreateStatementContext differentiates from other interfaces.
	IsCreateStatementContext()
}

ICreateStatementContext is an interface to support dynamic dispatch.

type ICreateTempFunctionContext

type ICreateTempFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	TEMPORARY() antlr.TerminalNode
	TempSqlInvokedFunction() ITempSqlInvokedFunctionContext
	OR() antlr.TerminalNode
	REPLACE() antlr.TerminalNode

	// IsCreateTempFunctionContext differentiates from other interfaces.
	IsCreateTempFunctionContext()
}

ICreateTempFunctionContext is an interface to support dynamic dispatch.

type ICtesContext

type ICtesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	AllNamedQuery() []INamedQueryContext
	NamedQuery(i int) INamedQueryContext
	RECURSIVE() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode
	TraversalOrderClause() ITraversalOrderClauseContext

	// IsCtesContext differentiates from other interfaces.
	IsCtesContext()
}

ICtesContext is an interface to support dynamic dispatch.

type ICurrentTimestampContext

type ICurrentTimestampContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NOW() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	CURRENT_TIMESTAMP() antlr.TerminalNode
	LOCALTIME() antlr.TerminalNode
	LOCALTIMESTAMP() antlr.TerminalNode
	DecimalLiteral() IDecimalLiteralContext

	// IsCurrentTimestampContext differentiates from other interfaces.
	IsCurrentTimestampContext()
}

ICurrentTimestampContext is an interface to support dynamic dispatch.

type IDataTypeContext

type IDataTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsDataTypeContext differentiates from other interfaces.
	IsDataTypeContext()
}

IDataTypeContext is an interface to support dynamic dispatch.

type IDdlStatementContext

type IDdlStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CreateStatement() ICreateStatementContext
	DropStatement() IDropStatementContext
	CreateTempFunction() ICreateTempFunctionContext
	DropTempFunction() IDropTempFunctionContext

	// IsDdlStatementContext differentiates from other interfaces.
	IsDdlStatementContext()
}

IDdlStatementContext is an interface to support dynamic dispatch.

type IDecimalLiteralContext

type IDecimalLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DECIMAL_LITERAL() antlr.TerminalNode
	REAL_LITERAL() antlr.TerminalNode

	// IsDecimalLiteralContext differentiates from other interfaces.
	IsDecimalLiteralContext()
}

IDecimalLiteralContext is an interface to support dynamic dispatch.

type IDeclareBlockContext

type IDeclareBlockContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DECLARE() antlr.TerminalNode
	AllDeclaredFunction() []IDeclaredFunctionContext
	DeclaredFunction(i int) IDeclaredFunctionContext
	AllSEMI() []antlr.TerminalNode
	SEMI(i int) antlr.TerminalNode

	// IsDeclareBlockContext differentiates from other interfaces.
	IsDeclareBlockContext()
}

IDeclareBlockContext is an interface to support dynamic dispatch.

type IDeclaredFunctionContext

type IDeclaredFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetFunctionName returns the functionName rule contexts.
	GetFunctionName() IUidContext

	// GetFunctionBody returns the functionBody rule contexts.
	GetFunctionBody() IQueryContext

	// SetFunctionName sets the functionName rule contexts.
	SetFunctionName(IUidContext)

	// SetFunctionBody sets the functionBody rule contexts.
	SetFunctionBody(IQueryContext)

	// Getter signatures
	FUNCTION() antlr.TerminalNode
	SqlParameterDeclarationList() ISqlParameterDeclarationListContext
	AS() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	Uid() IUidContext
	Query() IQueryContext

	// IsDeclaredFunctionContext differentiates from other interfaces.
	IsDeclaredFunctionContext()
}

IDeclaredFunctionContext is an interface to support dynamic dispatch.

type IDefaultValueContext

type IDefaultValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NULL_LITERAL() antlr.TerminalNode
	Constant() IConstantContext
	AllCurrentTimestamp() []ICurrentTimestampContext
	CurrentTimestamp(i int) ICurrentTimestampContext
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	Expression() IExpressionContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	ON() antlr.TerminalNode
	UPDATE() antlr.TerminalNode
	UnaryOperator() IUnaryOperatorContext

	// IsDefaultValueContext differentiates from other interfaces.
	IsDefaultValueContext()
}

IDefaultValueContext is an interface to support dynamic dispatch.

type IDeleteStatementContext

type IDeleteStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DELETE() antlr.TerminalNode
	FROM() antlr.TerminalNode
	TableName() ITableNameContext
	WHERE() antlr.TerminalNode
	WhereExpr() IWhereExprContext
	OrderByClause() IOrderByClauseContext
	LimitClause() ILimitClauseContext
	RETURNING() antlr.TerminalNode
	SelectElements() ISelectElementsContext
	StatementOptions() IStatementOptionsContext

	// IsDeleteStatementContext differentiates from other interfaces.
	IsDeleteStatementContext()
}

IDeleteStatementContext is an interface to support dynamic dispatch.

type IDescribeObjectClauseContext

type IDescribeObjectClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsDescribeObjectClauseContext differentiates from other interfaces.
	IsDescribeObjectClauseContext()
}

IDescribeObjectClauseContext is an interface to support dynamic dispatch.

type IDeterministicCharacteristicContext

type IDeterministicCharacteristicContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DETERMINISTIC() antlr.TerminalNode
	NOT() antlr.TerminalNode

	// IsDeterministicCharacteristicContext differentiates from other interfaces.
	IsDeterministicCharacteristicContext()
}

IDeterministicCharacteristicContext is an interface to support dynamic dispatch.

type IDispatchClauseContext

type IDispatchClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	STATIC() antlr.TerminalNode
	DISPATCH() antlr.TerminalNode

	// IsDispatchClauseContext differentiates from other interfaces.
	IsDispatchClauseContext()
}

IDispatchClauseContext is an interface to support dynamic dispatch.

type IDmlStatementContext

type IDmlStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	InsertStatement() IInsertStatementContext
	UpdateStatement() IUpdateStatementContext
	DeleteStatement() IDeleteStatementContext

	// IsDmlStatementContext differentiates from other interfaces.
	IsDmlStatementContext()
}

IDmlStatementContext is an interface to support dynamic dispatch.

type IDropStatementContext

type IDropStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsDropStatementContext differentiates from other interfaces.
	IsDropStatementContext()
}

IDropStatementContext is an interface to support dynamic dispatch.

type IDropTempFunctionContext

type IDropTempFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchemaQualifiedRoutineName returns the schemaQualifiedRoutineName rule contexts.
	GetSchemaQualifiedRoutineName() IFullIdContext

	// SetSchemaQualifiedRoutineName sets the schemaQualifiedRoutineName rule contexts.
	SetSchemaQualifiedRoutineName(IFullIdContext)

	// Getter signatures
	DROP() antlr.TerminalNode
	TEMPORARY() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	FullId() IFullIdContext
	IF() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsDropTempFunctionContext differentiates from other interfaces.
	IsDropTempFunctionContext()
}

IDropTempFunctionContext is an interface to support dynamic dispatch.

type IEnumDefinitionContext

type IEnumDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TYPE() antlr.TerminalNode
	AS() antlr.TerminalNode
	ENUM() antlr.TerminalNode
	Uid() IUidContext
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllSTRING_LITERAL() []antlr.TerminalNode
	STRING_LITERAL(i int) antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsEnumDefinitionContext differentiates from other interfaces.
	IsEnumDefinitionContext()
}

IEnumDefinitionContext is an interface to support dynamic dispatch.

type IExecuteContinuationStatementContext

type IExecuteContinuationStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPackageBytes returns the packageBytes rule contexts.
	GetPackageBytes() IContinuationAtomContext

	// SetPackageBytes sets the packageBytes rule contexts.
	SetPackageBytes(IContinuationAtomContext)

	// Getter signatures
	EXECUTE() antlr.TerminalNode
	CONTINUATION() antlr.TerminalNode
	ContinuationAtom() IContinuationAtomContext
	StatementOptions() IStatementOptionsContext

	// IsExecuteContinuationStatementContext differentiates from other interfaces.
	IsExecuteContinuationStatementContext()
}

IExecuteContinuationStatementContext is an interface to support dynamic dispatch.

type IExecuteStatementContext

type IExecuteStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EXECUTE() antlr.TerminalNode
	Uid() IUidContext
	USING() antlr.TerminalNode
	UserVariables() IUserVariablesContext

	// IsExecuteStatementContext differentiates from other interfaces.
	IsExecuteStatementContext()
}

IExecuteStatementContext is an interface to support dynamic dispatch.

type IExpressionAtomContext

type IExpressionAtomContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsExpressionAtomContext differentiates from other interfaces.
	IsExpressionAtomContext()
}

IExpressionAtomContext is an interface to support dynamic dispatch.

type IExpressionContext

type IExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsExpressionContext differentiates from other interfaces.
	IsExpressionContext()
}

IExpressionContext is an interface to support dynamic dispatch.

type IExpressionOrDefaultContext

type IExpressionOrDefaultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Expression() IExpressionContext
	DEFAULT() antlr.TerminalNode

	// IsExpressionOrDefaultContext differentiates from other interfaces.
	IsExpressionOrDefaultContext()
}

IExpressionOrDefaultContext is an interface to support dynamic dispatch.

type IExpressionWithOptionalNameContext

type IExpressionWithOptionalNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Expression() IExpressionContext
	AS() antlr.TerminalNode
	Uid() IUidContext

	// IsExpressionWithOptionalNameContext differentiates from other interfaces.
	IsExpressionWithOptionalNameContext()
}

IExpressionWithOptionalNameContext is an interface to support dynamic dispatch.

type IExpressionsContext

type IExpressionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllExpression() []IExpressionContext
	Expression(i int) IExpressionContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsExpressionsContext differentiates from other interfaces.
	IsExpressionsContext()
}

IExpressionsContext is an interface to support dynamic dispatch.

type IExpressionsWithDefaultsContext

type IExpressionsWithDefaultsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllExpressionOrDefault() []IExpressionOrDefaultContext
	ExpressionOrDefault(i int) IExpressionOrDefaultContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsExpressionsWithDefaultsContext differentiates from other interfaces.
	IsExpressionsWithDefaultsContext()
}

IExpressionsWithDefaultsContext is an interface to support dynamic dispatch.

type IFromClauseContext

type IFromClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FROM() antlr.TerminalNode
	TableSources() ITableSourcesContext
	WHERE() antlr.TerminalNode
	WhereExpr() IWhereExprContext

	// IsFromClauseContext differentiates from other interfaces.
	IsFromClauseContext()
}

IFromClauseContext is an interface to support dynamic dispatch.

type IFullColumnNameContext

type IFullColumnNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FullId() IFullIdContext

	// IsFullColumnNameContext differentiates from other interfaces.
	IsFullColumnNameContext()
}

IFullColumnNameContext is an interface to support dynamic dispatch.

type IFullDescribeStatementContext

type IFullDescribeStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCommand returns the command token.
	GetCommand() antlr.Token

	// GetFormatType returns the formatType token.
	GetFormatType() antlr.Token

	// GetFormatValue returns the formatValue token.
	GetFormatValue() antlr.Token

	// SetCommand sets the command token.
	SetCommand(antlr.Token)

	// SetFormatType sets the formatType token.
	SetFormatType(antlr.Token)

	// SetFormatValue sets the formatValue token.
	SetFormatValue(antlr.Token)

	// Getter signatures
	DescribeObjectClause() IDescribeObjectClauseContext
	EXPLAIN() antlr.TerminalNode
	DESCRIBE() antlr.TerminalNode
	DESC() antlr.TerminalNode
	EQUAL_SYMBOL() antlr.TerminalNode
	EXTENDED() antlr.TerminalNode
	PARTITIONS() antlr.TerminalNode
	FORMAT() antlr.TerminalNode
	TRADITIONAL() antlr.TerminalNode
	JSON() antlr.TerminalNode

	// IsFullDescribeStatementContext differentiates from other interfaces.
	IsFullDescribeStatementContext()
}

IFullDescribeStatementContext is an interface to support dynamic dispatch.

type IFullIdContext

type IFullIdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllUid() []IUidContext
	Uid(i int) IUidContext
	AllDOT() []antlr.TerminalNode
	DOT(i int) antlr.TerminalNode

	// IsFullIdContext differentiates from other interfaces.
	IsFullIdContext()
}

IFullIdContext is an interface to support dynamic dispatch.

type IFullIdListContext

type IFullIdListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllFullId() []IFullIdContext
	FullId(i int) IFullIdContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsFullIdListContext differentiates from other interfaces.
	IsFullIdListContext()
}

IFullIdListContext is an interface to support dynamic dispatch.

type IFunctionArgContext

type IFunctionArgContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Expression() IExpressionContext

	// IsFunctionArgContext differentiates from other interfaces.
	IsFunctionArgContext()
}

IFunctionArgContext is an interface to support dynamic dispatch.

type IFunctionArgsContext

type IFunctionArgsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFunctionArg() []IFunctionArgContext
	FunctionArg(i int) IFunctionArgContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsFunctionArgsContext differentiates from other interfaces.
	IsFunctionArgsContext()
}

IFunctionArgsContext is an interface to support dynamic dispatch.

type IFunctionCallContext

type IFunctionCallContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsFunctionCallContext differentiates from other interfaces.
	IsFunctionCallContext()
}

IFunctionCallContext is an interface to support dynamic dispatch.

type IFunctionColumnTypeContext

type IFunctionColumnTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCustomType returns the customType rule contexts.
	GetCustomType() IUidContext

	// SetCustomType sets the customType rule contexts.
	SetCustomType(IUidContext)

	// Getter signatures
	PrimitiveType() IPrimitiveTypeContext
	TYPE() antlr.TerminalNode
	Uid() IUidContext
	ARRAY() antlr.TerminalNode

	// IsFunctionColumnTypeContext differentiates from other interfaces.
	IsFunctionColumnTypeContext()
}

IFunctionColumnTypeContext is an interface to support dynamic dispatch.

type IFunctionNameBaseContext

type IFunctionNameBaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ABS() antlr.TerminalNode
	ACOS() antlr.TerminalNode
	ADDDATE() antlr.TerminalNode
	ADDTIME() antlr.TerminalNode
	AES_DECRYPT() antlr.TerminalNode
	AES_ENCRYPT() antlr.TerminalNode
	AREA() antlr.TerminalNode
	ASBINARY() antlr.TerminalNode
	ASIN() antlr.TerminalNode
	ASTEXT() antlr.TerminalNode
	ASWKB() antlr.TerminalNode
	ASWKT() antlr.TerminalNode
	ASYMMETRIC_DECRYPT() antlr.TerminalNode
	ASYMMETRIC_DERIVE() antlr.TerminalNode
	ASYMMETRIC_ENCRYPT() antlr.TerminalNode
	ASYMMETRIC_SIGN() antlr.TerminalNode
	ASYMMETRIC_VERIFY() antlr.TerminalNode
	ATAN() antlr.TerminalNode
	ATAN2() antlr.TerminalNode
	BENCHMARK() antlr.TerminalNode
	BIN() antlr.TerminalNode
	BIT_COUNT() antlr.TerminalNode
	BIT_LENGTH() antlr.TerminalNode
	BITMAP_BIT_POSITION() antlr.TerminalNode
	BITMAP_BUCKET_OFFSET() antlr.TerminalNode
	BITMAP_BUCKET_NUMBER() antlr.TerminalNode
	BUFFER() antlr.TerminalNode
	CEIL() antlr.TerminalNode
	CEILING() antlr.TerminalNode
	CENTROID() antlr.TerminalNode
	CHARACTER_LENGTH() antlr.TerminalNode
	CHARSET() antlr.TerminalNode
	CHAR_LENGTH() antlr.TerminalNode
	COERCIBILITY() antlr.TerminalNode
	COLLATION() antlr.TerminalNode
	COMPRESS() antlr.TerminalNode
	COALESCE() antlr.TerminalNode
	CONCAT() antlr.TerminalNode
	CONCAT_WS() antlr.TerminalNode
	CONNECTION_ID() antlr.TerminalNode
	CONV() antlr.TerminalNode
	CONVERT_TZ() antlr.TerminalNode
	COS() antlr.TerminalNode
	COSINE_DISTANCE() antlr.TerminalNode
	COT() antlr.TerminalNode
	CRC32() antlr.TerminalNode
	CREATE_ASYMMETRIC_PRIV_KEY() antlr.TerminalNode
	CREATE_ASYMMETRIC_PUB_KEY() antlr.TerminalNode
	CREATE_DH_PARAMETERS() antlr.TerminalNode
	CREATE_DIGEST() antlr.TerminalNode
	CROSSES() antlr.TerminalNode
	CUME_DIST() antlr.TerminalNode
	DATABASE() antlr.TerminalNode
	DATE() antlr.TerminalNode
	DATEDIFF() antlr.TerminalNode
	DATE_FORMAT() antlr.TerminalNode
	DAY() antlr.TerminalNode
	DAYNAME() antlr.TerminalNode
	DAYOFMONTH() antlr.TerminalNode
	DAYOFWEEK() antlr.TerminalNode
	DAYOFYEAR() antlr.TerminalNode
	DECODE() antlr.TerminalNode
	DEGREES() antlr.TerminalNode
	DENSE_RANK() antlr.TerminalNode
	DES_DECRYPT() antlr.TerminalNode
	DES_ENCRYPT() antlr.TerminalNode
	DIMENSION() antlr.TerminalNode
	DISJOINT() antlr.TerminalNode
	DOT_PRODUCT_DISTANCE() antlr.TerminalNode
	ELT() antlr.TerminalNode
	EUCLIDEAN_DISTANCE() antlr.TerminalNode
	EUCLIDEAN_SQUARE_DISTANCE() antlr.TerminalNode
	ENCODE() antlr.TerminalNode
	ENCRYPT() antlr.TerminalNode
	ENDPOINT() antlr.TerminalNode
	ENVELOPE() antlr.TerminalNode
	EQUALS() antlr.TerminalNode
	EXP() antlr.TerminalNode
	EXPORT_SET() antlr.TerminalNode
	EXTERIORRING() antlr.TerminalNode
	EXTRACTVALUE() antlr.TerminalNode
	FIELD() antlr.TerminalNode
	FIND_IN_SET() antlr.TerminalNode
	FIRST_VALUE() antlr.TerminalNode
	FLOOR() antlr.TerminalNode
	FORMAT() antlr.TerminalNode
	FOUND_ROWS() antlr.TerminalNode
	FROM_BASE64() antlr.TerminalNode
	FROM_DAYS() antlr.TerminalNode
	FROM_UNIXTIME() antlr.TerminalNode
	GEOMCOLLFROMTEXT() antlr.TerminalNode
	GEOMCOLLFROMWKB() antlr.TerminalNode
	GEOMETRYCOLLECTION() antlr.TerminalNode
	GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode
	GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode
	GEOMETRYFROMTEXT() antlr.TerminalNode
	GEOMETRYFROMWKB() antlr.TerminalNode
	GEOMETRYN() antlr.TerminalNode
	GEOMETRYTYPE() antlr.TerminalNode
	GEOMFROMTEXT() antlr.TerminalNode
	GEOMFROMWKB() antlr.TerminalNode
	GET_FORMAT() antlr.TerminalNode
	GET_LOCK() antlr.TerminalNode
	GLENGTH() antlr.TerminalNode
	GREATEST() antlr.TerminalNode
	GTID_SUBSET() antlr.TerminalNode
	GTID_SUBTRACT() antlr.TerminalNode
	HEX() antlr.TerminalNode
	HOUR() antlr.TerminalNode
	IFNULL() antlr.TerminalNode
	INET6_ATON() antlr.TerminalNode
	INET6_NTOA() antlr.TerminalNode
	INET_ATON() antlr.TerminalNode
	INET_NTOA() antlr.TerminalNode
	INSTR() antlr.TerminalNode
	INTERIORRINGN() antlr.TerminalNode
	INTERSECTS() antlr.TerminalNode
	INVISIBLE() antlr.TerminalNode
	ISCLOSED() antlr.TerminalNode
	ISEMPTY() antlr.TerminalNode
	ISNULL() antlr.TerminalNode
	ISSIMPLE() antlr.TerminalNode
	IS_FREE_LOCK() antlr.TerminalNode
	IS_IPV4() antlr.TerminalNode
	IS_IPV4_COMPAT() antlr.TerminalNode
	IS_IPV4_MAPPED() antlr.TerminalNode
	IS_IPV6() antlr.TerminalNode
	IS_USED_LOCK() antlr.TerminalNode
	LAG() antlr.TerminalNode
	LAST_INSERT_ID() antlr.TerminalNode
	LAST_VALUE() antlr.TerminalNode
	LCASE() antlr.TerminalNode
	LEAD() antlr.TerminalNode
	LEAST() antlr.TerminalNode
	LEN() antlr.TerminalNode
	LENGTH() antlr.TerminalNode
	LINEFROMTEXT() antlr.TerminalNode
	LINEFROMWKB() antlr.TerminalNode
	LINESTRING() antlr.TerminalNode
	LINESTRINGFROMTEXT() antlr.TerminalNode
	LINESTRINGFROMWKB() antlr.TerminalNode
	LN() antlr.TerminalNode
	LOAD_FILE() antlr.TerminalNode
	LOCATE() antlr.TerminalNode
	LOG() antlr.TerminalNode
	LOG10() antlr.TerminalNode
	LOG2() antlr.TerminalNode
	LOWER() antlr.TerminalNode
	LPAD() antlr.TerminalNode
	LTRIM() antlr.TerminalNode
	MAKEDATE() antlr.TerminalNode
	MAKETIME() antlr.TerminalNode
	MAKE_SET() antlr.TerminalNode
	MASTER_POS_WAIT() antlr.TerminalNode
	MBRCONTAINS() antlr.TerminalNode
	MBRDISJOINT() antlr.TerminalNode
	MBREQUAL() antlr.TerminalNode
	MBRINTERSECTS() antlr.TerminalNode
	MBROVERLAPS() antlr.TerminalNode
	MBRTOUCHES() antlr.TerminalNode
	MBRWITHIN() antlr.TerminalNode
	MD5() antlr.TerminalNode
	MICROSECOND() antlr.TerminalNode
	MINUTE() antlr.TerminalNode
	MLINEFROMTEXT() antlr.TerminalNode
	MLINEFROMWKB() antlr.TerminalNode
	MOD() antlr.TerminalNode
	MONTH() antlr.TerminalNode
	MONTHNAME() antlr.TerminalNode
	MPOINTFROMTEXT() antlr.TerminalNode
	MPOINTFROMWKB() antlr.TerminalNode
	MPOLYFROMTEXT() antlr.TerminalNode
	MPOLYFROMWKB() antlr.TerminalNode
	MULTILINESTRING() antlr.TerminalNode
	MULTILINESTRINGFROMTEXT() antlr.TerminalNode
	MULTILINESTRINGFROMWKB() antlr.TerminalNode
	MULTIPOINT() antlr.TerminalNode
	MULTIPOINTFROMTEXT() antlr.TerminalNode
	MULTIPOINTFROMWKB() antlr.TerminalNode
	MULTIPOLYGON() antlr.TerminalNode
	MULTIPOLYGONFROMTEXT() antlr.TerminalNode
	MULTIPOLYGONFROMWKB() antlr.TerminalNode
	NAME_CONST() antlr.TerminalNode
	NTH_VALUE() antlr.TerminalNode
	NTILE() antlr.TerminalNode
	NULLIF() antlr.TerminalNode
	NUMGEOMETRIES() antlr.TerminalNode
	NUMINTERIORRINGS() antlr.TerminalNode
	NUMPOINTS() antlr.TerminalNode
	OCT() antlr.TerminalNode
	OCTET_LENGTH() antlr.TerminalNode
	ORD() antlr.TerminalNode
	OVERLAPS() antlr.TerminalNode
	PERCENT_RANK() antlr.TerminalNode
	PERIOD_ADD() antlr.TerminalNode
	PERIOD_DIFF() antlr.TerminalNode
	PI() antlr.TerminalNode
	POINT() antlr.TerminalNode
	POINTFROMTEXT() antlr.TerminalNode
	POINTFROMWKB() antlr.TerminalNode
	POINTN() antlr.TerminalNode
	POLYFROMTEXT() antlr.TerminalNode
	POLYFROMWKB() antlr.TerminalNode
	POLYGON() antlr.TerminalNode
	POLYGONFROMTEXT() antlr.TerminalNode
	POLYGONFROMWKB() antlr.TerminalNode
	POSITION() antlr.TerminalNode
	POW() antlr.TerminalNode
	POWER() antlr.TerminalNode
	QUARTER() antlr.TerminalNode
	QUOTE() antlr.TerminalNode
	RADIANS() antlr.TerminalNode
	RAND() antlr.TerminalNode
	RANK() antlr.TerminalNode
	RANDOM_BYTES() antlr.TerminalNode
	RELEASE_LOCK() antlr.TerminalNode
	REVERSE() antlr.TerminalNode
	ROUND() antlr.TerminalNode
	ROW_COUNT() antlr.TerminalNode
	ROW_NUMBER() antlr.TerminalNode
	RPAD() antlr.TerminalNode
	RTRIM() antlr.TerminalNode
	SECOND() antlr.TerminalNode
	SEC_TO_TIME() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	SESSION_USER() antlr.TerminalNode
	SESSION_VARIABLES_ADMIN() antlr.TerminalNode
	SHA() antlr.TerminalNode
	SHA1() antlr.TerminalNode
	SHA2() antlr.TerminalNode
	SIGN() antlr.TerminalNode
	SIN() antlr.TerminalNode
	SLEEP() antlr.TerminalNode
	SOUNDEX() antlr.TerminalNode
	SQL_THREAD_WAIT_AFTER_GTIDS() antlr.TerminalNode
	SQRT() antlr.TerminalNode
	SRID() antlr.TerminalNode
	STARTPOINT() antlr.TerminalNode
	STRCMP() antlr.TerminalNode
	STR_TO_DATE() antlr.TerminalNode
	ST_AREA() antlr.TerminalNode
	ST_ASBINARY() antlr.TerminalNode
	ST_ASTEXT() antlr.TerminalNode
	ST_ASWKB() antlr.TerminalNode
	ST_ASWKT() antlr.TerminalNode
	ST_BUFFER() antlr.TerminalNode
	ST_CENTROID() antlr.TerminalNode
	ST_CONTAINS() antlr.TerminalNode
	ST_CROSSES() antlr.TerminalNode
	ST_DIFFERENCE() antlr.TerminalNode
	ST_DIMENSION() antlr.TerminalNode
	ST_DISJOINT() antlr.TerminalNode
	ST_DISTANCE() antlr.TerminalNode
	ST_ENDPOINT() antlr.TerminalNode
	ST_ENVELOPE() antlr.TerminalNode
	ST_EQUALS() antlr.TerminalNode
	ST_EXTERIORRING() antlr.TerminalNode
	ST_GEOMCOLLFROMTEXT() antlr.TerminalNode
	ST_GEOMCOLLFROMTXT() antlr.TerminalNode
	ST_GEOMCOLLFROMWKB() antlr.TerminalNode
	ST_GEOMETRYCOLLECTIONFROMTEXT() antlr.TerminalNode
	ST_GEOMETRYCOLLECTIONFROMWKB() antlr.TerminalNode
	ST_GEOMETRYFROMTEXT() antlr.TerminalNode
	ST_GEOMETRYFROMWKB() antlr.TerminalNode
	ST_GEOMETRYN() antlr.TerminalNode
	ST_GEOMETRYTYPE() antlr.TerminalNode
	ST_GEOMFROMTEXT() antlr.TerminalNode
	ST_GEOMFROMWKB() antlr.TerminalNode
	ST_INTERIORRINGN() antlr.TerminalNode
	ST_INTERSECTION() antlr.TerminalNode
	ST_INTERSECTS() antlr.TerminalNode
	ST_ISCLOSED() antlr.TerminalNode
	ST_ISEMPTY() antlr.TerminalNode
	ST_ISSIMPLE() antlr.TerminalNode
	ST_LINEFROMTEXT() antlr.TerminalNode
	ST_LINEFROMWKB() antlr.TerminalNode
	ST_LINESTRINGFROMTEXT() antlr.TerminalNode
	ST_LINESTRINGFROMWKB() antlr.TerminalNode
	ST_NUMGEOMETRIES() antlr.TerminalNode
	ST_NUMINTERIORRING() antlr.TerminalNode
	ST_NUMINTERIORRINGS() antlr.TerminalNode
	ST_NUMPOINTS() antlr.TerminalNode
	ST_OVERLAPS() antlr.TerminalNode
	ST_POINTFROMTEXT() antlr.TerminalNode
	ST_POINTFROMWKB() antlr.TerminalNode
	ST_POINTN() antlr.TerminalNode
	ST_POLYFROMTEXT() antlr.TerminalNode
	ST_POLYFROMWKB() antlr.TerminalNode
	ST_POLYGONFROMTEXT() antlr.TerminalNode
	ST_POLYGONFROMWKB() antlr.TerminalNode
	ST_SRID() antlr.TerminalNode
	ST_STARTPOINT() antlr.TerminalNode
	ST_SYMDIFFERENCE() antlr.TerminalNode
	ST_TOUCHES() antlr.TerminalNode
	ST_UNION() antlr.TerminalNode
	ST_WITHIN() antlr.TerminalNode
	ST_X() antlr.TerminalNode
	ST_Y() antlr.TerminalNode
	SUBDATE() antlr.TerminalNode
	SUBSTRING_INDEX() antlr.TerminalNode
	SUBTIME() antlr.TerminalNode
	SYSTEM_USER() antlr.TerminalNode
	TAN() antlr.TerminalNode
	TIME() antlr.TerminalNode
	TIMEDIFF() antlr.TerminalNode
	TIMESTAMP() antlr.TerminalNode
	TIMESTAMPADD() antlr.TerminalNode
	TIMESTAMPDIFF() antlr.TerminalNode
	TIME_FORMAT() antlr.TerminalNode
	TIME_TO_SEC() antlr.TerminalNode
	TOUCHES() antlr.TerminalNode
	TO_BASE64() antlr.TerminalNode
	TO_DAYS() antlr.TerminalNode
	TO_SECONDS() antlr.TerminalNode
	UCASE() antlr.TerminalNode
	UNCOMPRESS() antlr.TerminalNode
	UNCOMPRESSED_LENGTH() antlr.TerminalNode
	UNHEX() antlr.TerminalNode
	UNIX_TIMESTAMP() antlr.TerminalNode
	UPDATEXML() antlr.TerminalNode
	UPPER() antlr.TerminalNode
	VALIDATE_PASSWORD_STRENGTH() antlr.TerminalNode
	VERSION() antlr.TerminalNode
	VISIBLE() antlr.TerminalNode
	WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS() antlr.TerminalNode
	WEEK() antlr.TerminalNode
	WEEKDAY() antlr.TerminalNode
	WEEKOFYEAR() antlr.TerminalNode
	WEIGHT_STRING() antlr.TerminalNode
	WITHIN() antlr.TerminalNode
	YEAR() antlr.TerminalNode
	YEARWEEK() antlr.TerminalNode
	Y_FUNCTION() antlr.TerminalNode
	X_FUNCTION() antlr.TerminalNode
	JSON_ARRAY() antlr.TerminalNode
	JSON_OBJECT() antlr.TerminalNode
	JSON_QUOTE() antlr.TerminalNode
	JSON_CONTAINS() antlr.TerminalNode
	JSON_CONTAINS_PATH() antlr.TerminalNode
	JSON_EXTRACT() antlr.TerminalNode
	JSON_KEYS() antlr.TerminalNode
	JSON_OVERLAPS() antlr.TerminalNode
	JSON_SEARCH() antlr.TerminalNode
	JSON_VALUE() antlr.TerminalNode
	JSON_ARRAY_APPEND() antlr.TerminalNode
	JSON_ARRAY_INSERT() antlr.TerminalNode
	JSON_INSERT() antlr.TerminalNode
	JSON_MERGE() antlr.TerminalNode
	JSON_MERGE_PATCH() antlr.TerminalNode
	JSON_MERGE_PRESERVE() antlr.TerminalNode
	JSON_REMOVE() antlr.TerminalNode
	JSON_REPLACE() antlr.TerminalNode
	JSON_SET() antlr.TerminalNode
	JSON_UNQUOTE() antlr.TerminalNode
	JSON_DEPTH() antlr.TerminalNode
	JSON_LENGTH() antlr.TerminalNode
	JSON_TYPE() antlr.TerminalNode
	JSON_VALID() antlr.TerminalNode
	JSON_TABLE() antlr.TerminalNode
	JSON_SCHEMA_VALID() antlr.TerminalNode
	JSON_SCHEMA_VALIDATION_REPORT() antlr.TerminalNode
	JSON_PRETTY() antlr.TerminalNode
	JSON_STORAGE_FREE() antlr.TerminalNode
	JSON_STORAGE_SIZE() antlr.TerminalNode
	JSON_ARRAYAGG() antlr.TerminalNode
	JSON_OBJECTAGG() antlr.TerminalNode

	// IsFunctionNameBaseContext differentiates from other interfaces.
	IsFunctionNameBaseContext()
}

IFunctionNameBaseContext is an interface to support dynamic dispatch.

type IFunctionNameKeywordContext

type IFunctionNameKeywordContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT() antlr.TerminalNode
	RIGHT() antlr.TerminalNode

	// IsFunctionNameKeywordContext differentiates from other interfaces.
	IsFunctionNameKeywordContext()
}

IFunctionNameKeywordContext is an interface to support dynamic dispatch.

type IFunctionSpecificationContext

type IFunctionSpecificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchemaQualifiedRoutineName returns the schemaQualifiedRoutineName rule contexts.
	GetSchemaQualifiedRoutineName() IFullIdContext

	// SetSchemaQualifiedRoutineName sets the schemaQualifiedRoutineName rule contexts.
	SetSchemaQualifiedRoutineName(IFullIdContext)

	// Getter signatures
	FUNCTION() antlr.TerminalNode
	SqlParameterDeclarationList() ISqlParameterDeclarationListContext
	RoutineCharacteristics() IRoutineCharacteristicsContext
	FullId() IFullIdContext
	ReturnsClause() IReturnsClauseContext
	DispatchClause() IDispatchClauseContext

	// IsFunctionSpecificationContext differentiates from other interfaces.
	IsFunctionSpecificationContext()
}

IFunctionSpecificationContext is an interface to support dynamic dispatch.

type IGroupByClauseContext

type IGroupByClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	GROUP() antlr.TerminalNode
	BY() antlr.TerminalNode
	AllGroupByItem() []IGroupByItemContext
	GroupByItem(i int) IGroupByItemContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsGroupByClauseContext differentiates from other interfaces.
	IsGroupByClauseContext()
}

IGroupByClauseContext is an interface to support dynamic dispatch.

type IGroupByItemContext

type IGroupByItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOrder returns the order token.
	GetOrder() antlr.Token

	// SetOrder sets the order token.
	SetOrder(antlr.Token)

	// Getter signatures
	Expression() IExpressionContext
	Uid() IUidContext
	ASC() antlr.TerminalNode
	DESC() antlr.TerminalNode
	AS() antlr.TerminalNode

	// IsGroupByItemContext differentiates from other interfaces.
	IsGroupByItemContext()
}

IGroupByItemContext is an interface to support dynamic dispatch.

type IHavingClauseContext

type IHavingClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetHavingExpr returns the havingExpr rule contexts.
	GetHavingExpr() IExpressionContext

	// SetHavingExpr sets the havingExpr rule contexts.
	SetHavingExpr(IExpressionContext)

	// Getter signatures
	HAVING() antlr.TerminalNode
	Expression() IExpressionContext

	// IsHavingClauseContext differentiates from other interfaces.
	IsHavingClauseContext()
}

IHavingClauseContext is an interface to support dynamic dispatch.

type IHelpStatementContext

type IHelpStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	HELP() antlr.TerminalNode
	STRING_LITERAL() antlr.TerminalNode

	// IsHelpStatementContext differentiates from other interfaces.
	IsHelpStatementContext()
}

IHelpStatementContext is an interface to support dynamic dispatch.

type IHnswMetricContext

type IHnswMetricContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EUCLIDEAN_METRIC() antlr.TerminalNode
	EUCLIDEAN_SQUARE_METRIC() antlr.TerminalNode
	COSINE_METRIC() antlr.TerminalNode
	DOT_PRODUCT_METRIC() antlr.TerminalNode

	// IsHnswMetricContext differentiates from other interfaces.
	IsHnswMetricContext()
}

IHnswMetricContext is an interface to support dynamic dispatch.

type IIfExistsContext

type IIfExistsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IF() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsIfExistsContext differentiates from other interfaces.
	IsIfExistsContext()
}

IIfExistsContext is an interface to support dynamic dispatch.

type IIfNotExistsContext

type IIfNotExistsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IF() antlr.TerminalNode
	NOT() antlr.TerminalNode
	EXISTS() antlr.TerminalNode

	// IsIfNotExistsContext differentiates from other interfaces.
	IsIfNotExistsContext()
}

IIfNotExistsContext is an interface to support dynamic dispatch.

type IInListContext

type IInListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	QueryExpressionBody() IQueryExpressionBodyContext
	Expressions() IExpressionsContext
	PreparedStatementParameter() IPreparedStatementParameterContext
	FullColumnName() IFullColumnNameContext

	// IsInListContext differentiates from other interfaces.
	IsInListContext()
}

IInListContext is an interface to support dynamic dispatch.

type IIncludeClauseContext

type IIncludeClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	INCLUDE() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	UidList() IUidListContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode

	// IsIncludeClauseContext differentiates from other interfaces.
	IsIncludeClauseContext()
}

IIncludeClauseContext is an interface to support dynamic dispatch.

type IIndexAttributeContext

type IIndexAttributeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEGACY_EXTREMUM_EVER() antlr.TerminalNode

	// IsIndexAttributeContext differentiates from other interfaces.
	IsIndexAttributeContext()
}

IIndexAttributeContext is an interface to support dynamic dispatch.

type IIndexAttributesContext

type IIndexAttributesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	ATTRIBUTES() antlr.TerminalNode
	AllIndexAttribute() []IIndexAttributeContext
	IndexAttribute(i int) IIndexAttributeContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsIndexAttributesContext differentiates from other interfaces.
	IsIndexAttributesContext()
}

IIndexAttributesContext is an interface to support dynamic dispatch.

type IIndexColumnListContext

type IIndexColumnListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllIndexColumnSpec() []IIndexColumnSpecContext
	IndexColumnSpec(i int) IIndexColumnSpecContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsIndexColumnListContext differentiates from other interfaces.
	IsIndexColumnListContext()
}

IIndexColumnListContext is an interface to support dynamic dispatch.

type IIndexColumnNameContext

type IIndexColumnNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSortType returns the sortType token.
	GetSortType() antlr.Token

	// SetSortType sets the sortType token.
	SetSortType(antlr.Token)

	// Getter signatures
	Expression() IExpressionContext
	Uid() IUidContext
	STRING_LITERAL() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	DecimalLiteral() IDecimalLiteralContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	ASC() antlr.TerminalNode
	DESC() antlr.TerminalNode

	// IsIndexColumnNameContext differentiates from other interfaces.
	IsIndexColumnNameContext()
}

IIndexColumnNameContext is an interface to support dynamic dispatch.

type IIndexColumnNamesContext

type IIndexColumnNamesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllIndexColumnName() []IIndexColumnNameContext
	IndexColumnName(i int) IIndexColumnNameContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsIndexColumnNamesContext differentiates from other interfaces.
	IsIndexColumnNamesContext()
}

IIndexColumnNamesContext is an interface to support dynamic dispatch.

type IIndexColumnSpecContext

type IIndexColumnSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetColumnName returns the columnName rule contexts.
	GetColumnName() IUidContext

	// SetColumnName sets the columnName rule contexts.
	SetColumnName(IUidContext)

	// Getter signatures
	Uid() IUidContext
	OrderClause() IOrderClauseContext

	// IsIndexColumnSpecContext differentiates from other interfaces.
	IsIndexColumnSpecContext()
}

IIndexColumnSpecContext is an interface to support dynamic dispatch.

type IIndexDefinitionContext

type IIndexDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsIndexDefinitionContext differentiates from other interfaces.
	IsIndexDefinitionContext()
}

IIndexDefinitionContext is an interface to support dynamic dispatch.

type IIndexHintContext

type IIndexHintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetIndexHintAction returns the indexHintAction token.
	GetIndexHintAction() antlr.Token

	// GetKeyFormat returns the keyFormat token.
	GetKeyFormat() antlr.Token

	// SetIndexHintAction sets the indexHintAction token.
	SetIndexHintAction(antlr.Token)

	// SetKeyFormat sets the keyFormat token.
	SetKeyFormat(antlr.Token)

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	UidList() IUidListContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	USE() antlr.TerminalNode
	IGNORE() antlr.TerminalNode
	FORCE() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	KEY() antlr.TerminalNode
	FOR() antlr.TerminalNode
	IndexHintType() IIndexHintTypeContext

	// IsIndexHintContext differentiates from other interfaces.
	IsIndexHintContext()
}

IIndexHintContext is an interface to support dynamic dispatch.

type IIndexHintTypeContext

type IIndexHintTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	JOIN() antlr.TerminalNode
	ORDER() antlr.TerminalNode
	BY() antlr.TerminalNode
	GROUP() antlr.TerminalNode

	// IsIndexHintTypeContext differentiates from other interfaces.
	IsIndexHintTypeContext()
}

IIndexHintTypeContext is an interface to support dynamic dispatch.

type IIndexOptionContext

type IIndexOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEGACY_EXTREMUM_EVER() antlr.TerminalNode

	// IsIndexOptionContext differentiates from other interfaces.
	IsIndexOptionContext()
}

IIndexOptionContext is an interface to support dynamic dispatch.

type IIndexOptionsContext

type IIndexOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPTIONS() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllIndexOption() []IIndexOptionContext
	IndexOption(i int) IIndexOptionContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsIndexOptionsContext differentiates from other interfaces.
	IsIndexOptionsContext()
}

IIndexOptionsContext is an interface to support dynamic dispatch.

type IIndexPartitionClauseContext

type IIndexPartitionClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PARTITION() antlr.TerminalNode
	BY() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllIndexColumnSpec() []IIndexColumnSpecContext
	IndexColumnSpec(i int) IIndexColumnSpecContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsIndexPartitionClauseContext differentiates from other interfaces.
	IsIndexPartitionClauseContext()
}

IIndexPartitionClauseContext is an interface to support dynamic dispatch.

type IIndexTypeContext

type IIndexTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	UNIQUE() antlr.TerminalNode
	VECTOR() antlr.TerminalNode

	// IsIndexTypeContext differentiates from other interfaces.
	IsIndexTypeContext()
}

IIndexTypeContext is an interface to support dynamic dispatch.

type IInlineTableDefinitionContext

type IInlineTableDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TableName() ITableNameContext
	UidListWithNestingsInParens() IUidListWithNestingsInParensContext
	AS() antlr.TerminalNode

	// IsInlineTableDefinitionContext differentiates from other interfaces.
	IsInlineTableDefinitionContext()
}

IInlineTableDefinitionContext is an interface to support dynamic dispatch.

type IInsertStatementContext

type IInsertStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetColumns returns the columns rule contexts.
	GetColumns() IUidListWithNestingsInParensContext

	// SetColumns sets the columns rule contexts.
	SetColumns(IUidListWithNestingsInParensContext)

	// Getter signatures
	INSERT() antlr.TerminalNode
	TableName() ITableNameContext
	InsertStatementValue() IInsertStatementValueContext
	INTO() antlr.TerminalNode
	StatementOptions() IStatementOptionsContext
	UidListWithNestingsInParens() IUidListWithNestingsInParensContext

	// IsInsertStatementContext differentiates from other interfaces.
	IsInsertStatementContext()
}

IInsertStatementContext is an interface to support dynamic dispatch.

type IInsertStatementValueContext

type IInsertStatementValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsInsertStatementValueContext differentiates from other interfaces.
	IsInsertStatementValueContext()
}

IInsertStatementValueContext is an interface to support dynamic dispatch.

type IIntervalTypeBaseContext

type IIntervalTypeBaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	QUARTER() antlr.TerminalNode
	MONTH() antlr.TerminalNode
	DAY() antlr.TerminalNode
	HOUR() antlr.TerminalNode
	MINUTE() antlr.TerminalNode
	WEEK() antlr.TerminalNode
	SECOND() antlr.TerminalNode
	MICROSECOND() antlr.TerminalNode

	// IsIntervalTypeBaseContext differentiates from other interfaces.
	IsIntervalTypeBaseContext()
}

IIntervalTypeBaseContext is an interface to support dynamic dispatch.

type IIntervalTypeContext

type IIntervalTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IntervalTypeBase() IIntervalTypeBaseContext
	YEAR() antlr.TerminalNode
	YEAR_MONTH() antlr.TerminalNode
	DAY_HOUR() antlr.TerminalNode
	DAY_MINUTE() antlr.TerminalNode
	DAY_SECOND() antlr.TerminalNode
	HOUR_MINUTE() antlr.TerminalNode
	HOUR_SECOND() antlr.TerminalNode
	MINUTE_SECOND() antlr.TerminalNode
	SECOND_MICROSECOND() antlr.TerminalNode
	MINUTE_MICROSECOND() antlr.TerminalNode
	HOUR_MICROSECOND() antlr.TerminalNode
	DAY_MICROSECOND() antlr.TerminalNode

	// IsIntervalTypeContext differentiates from other interfaces.
	IsIntervalTypeContext()
}

IIntervalTypeContext is an interface to support dynamic dispatch.

type IJoinPartContext

type IJoinPartContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsJoinPartContext differentiates from other interfaces.
	IsJoinPartContext()
}

IJoinPartContext is an interface to support dynamic dispatch.

type IJsonOperatorContext

type IJsonOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	MINUS() antlr.TerminalNode
	AllGREATER_SYMBOL() []antlr.TerminalNode
	GREATER_SYMBOL(i int) antlr.TerminalNode

	// IsJsonOperatorContext differentiates from other interfaces.
	IsJsonOperatorContext()
}

IJsonOperatorContext is an interface to support dynamic dispatch.

type IKeywordsCanBeIdContext

type IKeywordsCanBeIdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CONNECTIVITY() antlr.TerminalNode
	EF_CONSTRUCTION() antlr.TerminalNode
	M_MAX() antlr.TerminalNode
	M_MAX_0() antlr.TerminalNode
	MAINTAIN_STATS_PROBABILITY() antlr.TerminalNode
	METRIC() antlr.TerminalNode
	RABITQ_NUM_EX_BITS() antlr.TerminalNode
	SAMPLE_VECTOR_STATS_PROBABILITY() antlr.TerminalNode
	STATS_THRESHOLD() antlr.TerminalNode
	USE_RABITQ() antlr.TerminalNode
	ACCOUNT() antlr.TerminalNode
	ACTION() antlr.TerminalNode
	ADMIN() antlr.TerminalNode
	AFTER() antlr.TerminalNode
	AGGREGATE() antlr.TerminalNode
	ALGORITHM() antlr.TerminalNode
	ANY() antlr.TerminalNode
	ARRAY_AGG() antlr.TerminalNode
	AT() antlr.TerminalNode
	AUDIT_ADMIN() antlr.TerminalNode
	AUTHORS() antlr.TerminalNode
	AUTOCOMMIT() antlr.TerminalNode
	AUTOEXTEND_SIZE() antlr.TerminalNode
	AUTO_INCREMENT() antlr.TerminalNode
	AVG() antlr.TerminalNode
	AVG_ROW_LENGTH() antlr.TerminalNode
	BACKUP_ADMIN() antlr.TerminalNode
	BEGIN() antlr.TerminalNode
	BINLOG() antlr.TerminalNode
	BINLOG_ADMIN() antlr.TerminalNode
	BINLOG_ENCRYPTION_ADMIN() antlr.TerminalNode
	BIT() antlr.TerminalNode
	BIT_AND() antlr.TerminalNode
	BIT_OR() antlr.TerminalNode
	BIT_XOR() antlr.TerminalNode
	BLOCK() antlr.TerminalNode
	BOOL() antlr.TerminalNode
	BTREE() antlr.TerminalNode
	CACHE() antlr.TerminalNode
	CASCADED() antlr.TerminalNode
	CHAIN() antlr.TerminalNode
	CHANGED() antlr.TerminalNode
	CHANNEL() antlr.TerminalNode
	CHECKSUM() antlr.TerminalNode
	PAGE_CHECKSUM() antlr.TerminalNode
	CATALOG_NAME() antlr.TerminalNode
	CIPHER() antlr.TerminalNode
	CLASS_ORIGIN() antlr.TerminalNode
	CLIENT() antlr.TerminalNode
	CLONE_ADMIN() antlr.TerminalNode
	CLOSE() antlr.TerminalNode
	CLUSTERING() antlr.TerminalNode
	COALESCE() antlr.TerminalNode
	CODE() antlr.TerminalNode
	COLUMNS() antlr.TerminalNode
	COLUMN_FORMAT() antlr.TerminalNode
	COLUMN_NAME() antlr.TerminalNode
	COMMENT() antlr.TerminalNode
	COMMIT() antlr.TerminalNode
	COMPACT() antlr.TerminalNode
	COMPLETION() antlr.TerminalNode
	COMPRESSED() antlr.TerminalNode
	COMPRESSION() antlr.TerminalNode
	CONCURRENT() antlr.TerminalNode
	CONNECT() antlr.TerminalNode
	CONNECTION() antlr.TerminalNode
	CONNECTION_ADMIN() antlr.TerminalNode
	CONSISTENT() antlr.TerminalNode
	CONSTRAINT_CATALOG() antlr.TerminalNode
	CONSTRAINT_NAME() antlr.TerminalNode
	CONSTRAINT_SCHEMA() antlr.TerminalNode
	CONTAINS() antlr.TerminalNode
	CONTEXT() antlr.TerminalNode
	CONTRIBUTORS() antlr.TerminalNode
	COPY() antlr.TerminalNode
	CPU() antlr.TerminalNode
	CURRENT() antlr.TerminalNode
	CURSOR_NAME() antlr.TerminalNode
	DATA() antlr.TerminalNode
	DATAFILE() antlr.TerminalNode
	DATABASES() antlr.TerminalNode
	DEALLOCATE() antlr.TerminalNode
	DEFAULT_AUTH() antlr.TerminalNode
	DEFINER() antlr.TerminalNode
	DELAY_KEY_WRITE() antlr.TerminalNode
	DES_KEY_FILE() antlr.TerminalNode
	DIRECTORY() antlr.TerminalNode
	DISABLE() antlr.TerminalNode
	DISCARD() antlr.TerminalNode
	DISK() antlr.TerminalNode
	DO() antlr.TerminalNode
	DUMPFILE() antlr.TerminalNode
	DUPLICATE() antlr.TerminalNode
	DYNAMIC() antlr.TerminalNode
	ENABLE() antlr.TerminalNode
	ENCRYPTION() antlr.TerminalNode
	ENCRYPTION_KEY_ADMIN() antlr.TerminalNode
	END() antlr.TerminalNode
	ENDS() antlr.TerminalNode
	ENGINE() antlr.TerminalNode
	ENGINE_ATTRIBUTE() antlr.TerminalNode
	ENGINES() antlr.TerminalNode
	ERROR() antlr.TerminalNode
	ERRORS() antlr.TerminalNode
	ESCAPE() antlr.TerminalNode
	EUR() antlr.TerminalNode
	EVEN() antlr.TerminalNode
	EVENT() antlr.TerminalNode
	EVENTS() antlr.TerminalNode
	EVERY() antlr.TerminalNode
	EXCEPT() antlr.TerminalNode
	EXCHANGE() antlr.TerminalNode
	EXCLUSIVE() antlr.TerminalNode
	EXIT() antlr.TerminalNode
	EXPIRE() antlr.TerminalNode
	EXPORT() antlr.TerminalNode
	EXTENDED() antlr.TerminalNode
	EXTENT_SIZE() antlr.TerminalNode
	FAST() antlr.TerminalNode
	FAULTS() antlr.TerminalNode
	FIELDS() antlr.TerminalNode
	FILE_BLOCK_SIZE() antlr.TerminalNode
	FILTER() antlr.TerminalNode
	FIREWALL_ADMIN() antlr.TerminalNode
	FIREWALL_USER() antlr.TerminalNode
	FIRST() antlr.TerminalNode
	FIXED() antlr.TerminalNode
	FLUSH() antlr.TerminalNode
	FOLLOWS() antlr.TerminalNode
	FOUND() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	GENERAL() antlr.TerminalNode
	GLOBAL() antlr.TerminalNode
	GRANTS() antlr.TerminalNode
	GROUP() antlr.TerminalNode
	GROUP_CONCAT() antlr.TerminalNode
	HANDLER() antlr.TerminalNode
	HASH() antlr.TerminalNode
	HELP() antlr.TerminalNode
	HOST() antlr.TerminalNode
	HOSTS() antlr.TerminalNode
	IDENTIFIED() antlr.TerminalNode
	IGNORED() antlr.TerminalNode
	IGNORE_SERVER_IDS() antlr.TerminalNode
	IMPORT() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	INDEXES() antlr.TerminalNode
	INITIAL_SIZE() antlr.TerminalNode
	INNODB_REDO_LOG_ARCHIVE() antlr.TerminalNode
	INPLACE() antlr.TerminalNode
	INSERT_METHOD() antlr.TerminalNode
	INSTALL() antlr.TerminalNode
	INSTANCE() antlr.TerminalNode
	INSTANT() antlr.TerminalNode
	INTERNAL() antlr.TerminalNode
	INVOKER() antlr.TerminalNode
	IO() antlr.TerminalNode
	IO_THREAD() antlr.TerminalNode
	IPC() antlr.TerminalNode
	ISO() antlr.TerminalNode
	ISOLATION() antlr.TerminalNode
	ISSUER() antlr.TerminalNode
	JIS() antlr.TerminalNode
	JSON() antlr.TerminalNode
	KEY() antlr.TerminalNode
	KEY_BLOCK_SIZE() antlr.TerminalNode
	LANGUAGE() antlr.TerminalNode
	LAST() antlr.TerminalNode
	LEAVES() antlr.TerminalNode
	LESS() antlr.TerminalNode
	LEVEL() antlr.TerminalNode
	LIST() antlr.TerminalNode
	LOCAL() antlr.TerminalNode
	LOGFILE() antlr.TerminalNode
	LOGS() antlr.TerminalNode
	MASTER() antlr.TerminalNode
	MASTER_AUTO_POSITION() antlr.TerminalNode
	MASTER_CONNECT_RETRY() antlr.TerminalNode
	MASTER_DELAY() antlr.TerminalNode
	MASTER_HEARTBEAT_PERIOD() antlr.TerminalNode
	MASTER_HOST() antlr.TerminalNode
	MASTER_LOG_FILE() antlr.TerminalNode
	MASTER_LOG_POS() antlr.TerminalNode
	MASTER_PASSWORD() antlr.TerminalNode
	MASTER_PORT() antlr.TerminalNode
	MASTER_RETRY_COUNT() antlr.TerminalNode
	MASTER_SSL() antlr.TerminalNode
	MASTER_SSL_CA() antlr.TerminalNode
	MASTER_SSL_CAPATH() antlr.TerminalNode
	MASTER_SSL_CERT() antlr.TerminalNode
	MASTER_SSL_CIPHER() antlr.TerminalNode
	MASTER_SSL_CRL() antlr.TerminalNode
	MASTER_SSL_CRLPATH() antlr.TerminalNode
	MASTER_SSL_KEY() antlr.TerminalNode
	MASTER_TLS_VERSION() antlr.TerminalNode
	MASTER_USER() antlr.TerminalNode
	MAX_CONNECTIONS_PER_HOUR() antlr.TerminalNode
	MAX_QUERIES_PER_HOUR() antlr.TerminalNode
	MAX() antlr.TerminalNode
	MAX_ROWS() antlr.TerminalNode
	MAX_SIZE() antlr.TerminalNode
	MAX_UPDATES_PER_HOUR() antlr.TerminalNode
	MAX_USER_CONNECTIONS() antlr.TerminalNode
	MEDIUM() antlr.TerminalNode
	MEMBER() antlr.TerminalNode
	MEMORY() antlr.TerminalNode
	MERGE() antlr.TerminalNode
	MESSAGE() antlr.TerminalNode
	MESSAGE_TEXT() antlr.TerminalNode
	MID() antlr.TerminalNode
	MIGRATE() antlr.TerminalNode
	MIN() antlr.TerminalNode
	MIN_ROWS() antlr.TerminalNode
	MODE() antlr.TerminalNode
	MODIFY() antlr.TerminalNode
	MUTEX() antlr.TerminalNode
	MYSQL() antlr.TerminalNode
	MYSQL_ERRNO() antlr.TerminalNode
	NAME() antlr.TerminalNode
	NAMES() antlr.TerminalNode
	NCHAR() antlr.TerminalNode
	NDB_STORED_USER() antlr.TerminalNode
	NEVER() antlr.TerminalNode
	NEXT() antlr.TerminalNode
	NO() antlr.TerminalNode
	NOCOPY() antlr.TerminalNode
	NODEGROUP() antlr.TerminalNode
	NOCACHE() antlr.TerminalNode
	NONE() antlr.TerminalNode
	NOWAIT() antlr.TerminalNode
	NUMBER() antlr.TerminalNode
	ODBC() antlr.TerminalNode
	OFFLINE() antlr.TerminalNode
	OFFSET() antlr.TerminalNode
	OF() antlr.TerminalNode
	OJ() antlr.TerminalNode
	OLD_PASSWORD() antlr.TerminalNode
	ONE() antlr.TerminalNode
	ONLINE() antlr.TerminalNode
	ONLY() antlr.TerminalNode
	OPEN() antlr.TerminalNode
	OPTIMIZER_COSTS() antlr.TerminalNode
	OPTIONAL() antlr.TerminalNode
	OPTIONS() antlr.TerminalNode
	ORDER() antlr.TerminalNode
	OWNER() antlr.TerminalNode
	PACK_KEYS() antlr.TerminalNode
	PAGE() antlr.TerminalNode
	PARSER() antlr.TerminalNode
	PARTIAL() antlr.TerminalNode
	PARTITIONING() antlr.TerminalNode
	PARTITIONS() antlr.TerminalNode
	PASSWORD() antlr.TerminalNode
	PERSIST_RO_VARIABLES_ADMIN() antlr.TerminalNode
	PHASE() antlr.TerminalNode
	PLUGINS() antlr.TerminalNode
	PLUGIN_DIR() antlr.TerminalNode
	PLUGIN() antlr.TerminalNode
	PORT() antlr.TerminalNode
	PRECEDES() antlr.TerminalNode
	PREPARE() antlr.TerminalNode
	PRESERVE() antlr.TerminalNode
	PREV() antlr.TerminalNode
	PROCESSLIST() antlr.TerminalNode
	PROFILE() antlr.TerminalNode
	PROFILES() antlr.TerminalNode
	PROXY() antlr.TerminalNode
	QUERY() antlr.TerminalNode
	QUICK() antlr.TerminalNode
	REBUILD() antlr.TerminalNode
	RECOVER() antlr.TerminalNode
	REDO_BUFFER_SIZE() antlr.TerminalNode
	REDUNDANT() antlr.TerminalNode
	RELAY() antlr.TerminalNode
	RELAYLOG() antlr.TerminalNode
	RELAY_LOG_FILE() antlr.TerminalNode
	RELAY_LOG_POS() antlr.TerminalNode
	REMOVE() antlr.TerminalNode
	REORGANIZE() antlr.TerminalNode
	REPAIR() antlr.TerminalNode
	RESET() antlr.TerminalNode
	RESPECT() antlr.TerminalNode
	RESOURCE_GROUP_ADMIN() antlr.TerminalNode
	RESOURCE_GROUP_USER() antlr.TerminalNode
	RESUME() antlr.TerminalNode
	RETURNED_SQLSTATE() antlr.TerminalNode
	RETURNS() antlr.TerminalNode
	ROLE() antlr.TerminalNode
	ROLE_ADMIN() antlr.TerminalNode
	ROLLBACK() antlr.TerminalNode
	ROLLUP() antlr.TerminalNode
	ROTATE() antlr.TerminalNode
	ROW() antlr.TerminalNode
	ROWS() antlr.TerminalNode
	ROW_FORMAT() antlr.TerminalNode
	RTREE() antlr.TerminalNode
	SAVEPOINT() antlr.TerminalNode
	SCHEDULE() antlr.TerminalNode
	SCHEMA() antlr.TerminalNode
	SCHEMAS() antlr.TerminalNode
	SCHEMA_NAME() antlr.TerminalNode
	SECURITY() antlr.TerminalNode
	SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode
	SERIAL() antlr.TerminalNode
	SERVER() antlr.TerminalNode
	SESSION() antlr.TerminalNode
	SESSION_VARIABLES_ADMIN() antlr.TerminalNode
	SET_USER_ID() antlr.TerminalNode
	SHARE() antlr.TerminalNode
	SHARED() antlr.TerminalNode
	SHOW_ROUTINE() antlr.TerminalNode
	SIGNED() antlr.TerminalNode
	SIMPLE() antlr.TerminalNode
	SLAVE() antlr.TerminalNode
	SLOW() antlr.TerminalNode
	SNAPSHOT() antlr.TerminalNode
	SOCKET() antlr.TerminalNode
	SOME() antlr.TerminalNode
	SONAME() antlr.TerminalNode
	SOUNDS() antlr.TerminalNode
	SOURCE() antlr.TerminalNode
	SQL_AFTER_GTIDS() antlr.TerminalNode
	SQL_AFTER_MTS_GAPS() antlr.TerminalNode
	SQL_BEFORE_GTIDS() antlr.TerminalNode
	SQL_BUFFER_RESULT() antlr.TerminalNode
	SQL_THREAD() antlr.TerminalNode
	STACKED() antlr.TerminalNode
	START() antlr.TerminalNode
	STARTS() antlr.TerminalNode
	STATS_AUTO_RECALC() antlr.TerminalNode
	STATS_PERSISTENT() antlr.TerminalNode
	STATS_SAMPLE_PAGES() antlr.TerminalNode
	STATUS() antlr.TerminalNode
	STD() antlr.TerminalNode
	STDDEV() antlr.TerminalNode
	STDDEV_POP() antlr.TerminalNode
	STDDEV_SAMP() antlr.TerminalNode
	STOP() antlr.TerminalNode
	STORAGE() antlr.TerminalNode
	SUBCLASS_ORIGIN() antlr.TerminalNode
	SUBJECT() antlr.TerminalNode
	SUBPARTITION() antlr.TerminalNode
	SUBPARTITIONS() antlr.TerminalNode
	SUM() antlr.TerminalNode
	SUSPEND() antlr.TerminalNode
	SWAPS() antlr.TerminalNode
	SWITCHES() antlr.TerminalNode
	SYSTEM_VARIABLES_ADMIN() antlr.TerminalNode
	TABLE_NAME() antlr.TerminalNode
	TABLESPACE() antlr.TerminalNode
	TABLE_ENCRYPTION_ADMIN() antlr.TerminalNode
	TEXT() antlr.TerminalNode
	TEMPORARY() antlr.TerminalNode
	TEMPTABLE() antlr.TerminalNode
	THAN() antlr.TerminalNode
	TRADITIONAL() antlr.TerminalNode
	TRANSACTION() antlr.TerminalNode
	TRANSACTIONAL() antlr.TerminalNode
	TRIGGERS() antlr.TerminalNode
	TRUNCATE() antlr.TerminalNode
	UNDEFINED() antlr.TerminalNode
	UNDOFILE() antlr.TerminalNode
	UNDO_BUFFER_SIZE() antlr.TerminalNode
	UNINSTALL() antlr.TerminalNode
	UNKNOWN() antlr.TerminalNode
	UNTIL() antlr.TerminalNode
	UPGRADE() antlr.TerminalNode
	USA() antlr.TerminalNode
	USER() antlr.TerminalNode
	USE_FRM() antlr.TerminalNode
	USER_RESOURCES() antlr.TerminalNode
	VALIDATION() antlr.TerminalNode
	VALUE() antlr.TerminalNode
	VAR_POP() antlr.TerminalNode
	VAR_SAMP() antlr.TerminalNode
	VARIABLES() antlr.TerminalNode
	VARIANCE() antlr.TerminalNode
	VERSION_TOKEN_ADMIN() antlr.TerminalNode
	VIEW() antlr.TerminalNode
	WAIT() antlr.TerminalNode
	WARNINGS() antlr.TerminalNode
	WITHOUT() antlr.TerminalNode
	WRAPPER() antlr.TerminalNode
	X509() antlr.TerminalNode
	XA() antlr.TerminalNode
	XA_RECOVER_ADMIN() antlr.TerminalNode
	XML() antlr.TerminalNode

	// IsKeywordsCanBeIdContext differentiates from other interfaces.
	IsKeywordsCanBeIdContext()
}

IKeywordsCanBeIdContext is an interface to support dynamic dispatch.

type IKillStatementContext

type IKillStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetConnectionFormat returns the connectionFormat token.
	GetConnectionFormat() antlr.Token

	// SetConnectionFormat sets the connectionFormat token.
	SetConnectionFormat(antlr.Token)

	// Getter signatures
	KILL() antlr.TerminalNode
	AllDecimalLiteral() []IDecimalLiteralContext
	DecimalLiteral(i int) IDecimalLiteralContext
	CONNECTION() antlr.TerminalNode
	QUERY() antlr.TerminalNode

	// IsKillStatementContext differentiates from other interfaces.
	IsKillStatementContext()
}

IKillStatementContext is an interface to support dynamic dispatch.

type ILanguageClauseContext

type ILanguageClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LANGUAGE() antlr.TerminalNode
	LanguageName() ILanguageNameContext

	// IsLanguageClauseContext differentiates from other interfaces.
	IsLanguageClauseContext()
}

ILanguageClauseContext is an interface to support dynamic dispatch.

type ILanguageNameContext

type ILanguageNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SQL() antlr.TerminalNode
	JAVA() antlr.TerminalNode

	// IsLanguageNameContext differentiates from other interfaces.
	IsLanguageNameContext()
}

ILanguageNameContext is an interface to support dynamic dispatch.

type ILengthOneDimensionContext

type ILengthOneDimensionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	DecimalLiteral() IDecimalLiteralContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode

	// IsLengthOneDimensionContext differentiates from other interfaces.
	IsLengthOneDimensionContext()
}

ILengthOneDimensionContext is an interface to support dynamic dispatch.

type ILengthTwoDimensionContext

type ILengthTwoDimensionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllDecimalLiteral() []IDecimalLiteralContext
	DecimalLiteral(i int) IDecimalLiteralContext
	COMMA() antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode

	// IsLengthTwoDimensionContext differentiates from other interfaces.
	IsLengthTwoDimensionContext()
}

ILengthTwoDimensionContext is an interface to support dynamic dispatch.

type ILengthTwoOptionalDimensionContext

type ILengthTwoOptionalDimensionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllDecimalLiteral() []IDecimalLiteralContext
	DecimalLiteral(i int) IDecimalLiteralContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	COMMA() antlr.TerminalNode

	// IsLengthTwoOptionalDimensionContext differentiates from other interfaces.
	IsLengthTwoOptionalDimensionContext()
}

ILengthTwoOptionalDimensionContext is an interface to support dynamic dispatch.

type ILevelInWeightListElementContext

type ILevelInWeightListElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOrderType returns the orderType token.
	GetOrderType() antlr.Token

	// SetOrderType sets the orderType token.
	SetOrderType(antlr.Token)

	// Getter signatures
	DecimalLiteral() IDecimalLiteralContext
	ASC() antlr.TerminalNode
	DESC() antlr.TerminalNode
	REVERSE() antlr.TerminalNode

	// IsLevelInWeightListElementContext differentiates from other interfaces.
	IsLevelInWeightListElementContext()
}

ILevelInWeightListElementContext is an interface to support dynamic dispatch.

type ILevelsInWeightStringContext

type ILevelsInWeightStringContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsLevelsInWeightStringContext differentiates from other interfaces.
	IsLevelsInWeightStringContext()
}

ILevelsInWeightStringContext is an interface to support dynamic dispatch.

type ILimitClauseAtomContext

type ILimitClauseAtomContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DecimalLiteral() IDecimalLiteralContext
	PreparedStatementParameter() IPreparedStatementParameterContext

	// IsLimitClauseAtomContext differentiates from other interfaces.
	IsLimitClauseAtomContext()
}

ILimitClauseAtomContext is an interface to support dynamic dispatch.

type ILimitClauseContext

type ILimitClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetLimit returns the limit rule contexts.
	GetLimit() ILimitClauseAtomContext

	// GetOffset returns the offset rule contexts.
	GetOffset() ILimitClauseAtomContext

	// SetLimit sets the limit rule contexts.
	SetLimit(ILimitClauseAtomContext)

	// SetOffset sets the offset rule contexts.
	SetOffset(ILimitClauseAtomContext)

	// Getter signatures
	LIMIT() antlr.TerminalNode
	AllLimitClauseAtom() []ILimitClauseAtomContext
	LimitClauseAtom(i int) ILimitClauseAtomContext
	OFFSET() antlr.TerminalNode

	// IsLimitClauseContext differentiates from other interfaces.
	IsLimitClauseContext()
}

ILimitClauseContext is an interface to support dynamic dispatch.

type ILoadedTableIndexesContext

type ILoadedTableIndexesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetIndexFormat returns the indexFormat token.
	GetIndexFormat() antlr.Token

	// SetIndexFormat sets the indexFormat token.
	SetIndexFormat(antlr.Token)

	// GetPartitionList returns the partitionList rule contexts.
	GetPartitionList() IUidListContext

	// GetIndexList returns the indexList rule contexts.
	GetIndexList() IUidListContext

	// SetPartitionList sets the partitionList rule contexts.
	SetPartitionList(IUidListContext)

	// SetIndexList sets the indexList rule contexts.
	SetIndexList(IUidListContext)

	// Getter signatures
	TableName() ITableNameContext
	PARTITION() antlr.TerminalNode
	AllLEFT_ROUND_BRACKET() []antlr.TerminalNode
	LEFT_ROUND_BRACKET(i int) antlr.TerminalNode
	AllRIGHT_ROUND_BRACKET() []antlr.TerminalNode
	RIGHT_ROUND_BRACKET(i int) antlr.TerminalNode
	IGNORE() antlr.TerminalNode
	LEAVES() antlr.TerminalNode
	AllUidList() []IUidListContext
	UidList(i int) IUidListContext
	ALL() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	KEY() antlr.TerminalNode

	// IsLoadedTableIndexesContext differentiates from other interfaces.
	IsLoadedTableIndexesContext()
}

ILoadedTableIndexesContext is an interface to support dynamic dispatch.

type ILogicalOperatorContext

type ILogicalOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AND() antlr.TerminalNode
	AllBIT_AND_OP() []antlr.TerminalNode
	BIT_AND_OP(i int) antlr.TerminalNode
	XOR() antlr.TerminalNode
	OR() antlr.TerminalNode
	AllBIT_OR_OP() []antlr.TerminalNode
	BIT_OR_OP(i int) antlr.TerminalNode

	// IsLogicalOperatorContext differentiates from other interfaces.
	IsLogicalOperatorContext()
}

ILogicalOperatorContext is an interface to support dynamic dispatch.

type IMathOperatorContext

type IMathOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	STAR() antlr.TerminalNode
	DIVIDE() antlr.TerminalNode
	MODULE() antlr.TerminalNode
	DIV() antlr.TerminalNode
	MOD() antlr.TerminalNode
	PLUS() antlr.TerminalNode
	MINUS() antlr.TerminalNode

	// IsMathOperatorContext differentiates from other interfaces.
	IsMathOperatorContext()
}

IMathOperatorContext is an interface to support dynamic dispatch.

type INamedFunctionArgContext

type INamedFunctionArgContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetKey returns the key rule contexts.
	GetKey() IUidContext

	// GetValue returns the value rule contexts.
	GetValue() IExpressionContext

	// SetKey sets the key rule contexts.
	SetKey(IUidContext)

	// SetValue sets the value rule contexts.
	SetValue(IExpressionContext)

	// Getter signatures
	NAMED_ARG_ASSIGN_TOKEN() antlr.TerminalNode
	Uid() IUidContext
	Expression() IExpressionContext

	// IsNamedFunctionArgContext differentiates from other interfaces.
	IsNamedFunctionArgContext()
}

INamedFunctionArgContext is an interface to support dynamic dispatch.

type INamedOrUnnamedFunctionArgsContext

type INamedOrUnnamedFunctionArgsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllFunctionArg() []IFunctionArgContext
	FunctionArg(i int) IFunctionArgContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode
	AllNamedFunctionArg() []INamedFunctionArgContext
	NamedFunctionArg(i int) INamedFunctionArgContext

	// IsNamedOrUnnamedFunctionArgsContext differentiates from other interfaces.
	IsNamedOrUnnamedFunctionArgsContext()
}

INamedOrUnnamedFunctionArgsContext is an interface to support dynamic dispatch.

type INamedQueryContext

type INamedQueryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetName returns the name rule contexts.
	GetName() IFullIdContext

	// GetColumnAliases returns the columnAliases rule contexts.
	GetColumnAliases() IFullIdListContext

	// SetName sets the name rule contexts.
	SetName(IFullIdContext)

	// SetColumnAliases sets the columnAliases rule contexts.
	SetColumnAliases(IFullIdListContext)

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	Query() IQueryContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	FullId() IFullIdContext
	AS() antlr.TerminalNode
	FullIdList() IFullIdListContext

	// IsNamedQueryContext differentiates from other interfaces.
	IsNamedQueryContext()
}

INamedQueryContext is an interface to support dynamic dispatch.

type INonAggregateWindowedFunctionContext

type INonAggregateWindowedFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetFunctionName returns the functionName token.
	GetFunctionName() antlr.Token

	// SetFunctionName sets the functionName token.
	SetFunctionName(antlr.Token)

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	Expression() IExpressionContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	OverClause() IOverClauseContext
	LAG() antlr.TerminalNode
	LEAD() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode
	AllDecimalLiteral() []IDecimalLiteralContext
	DecimalLiteral(i int) IDecimalLiteralContext
	FIRST_VALUE() antlr.TerminalNode
	LAST_VALUE() antlr.TerminalNode
	CUME_DIST() antlr.TerminalNode
	DENSE_RANK() antlr.TerminalNode
	PERCENT_RANK() antlr.TerminalNode
	RANK() antlr.TerminalNode
	ROW_NUMBER() antlr.TerminalNode
	NTH_VALUE() antlr.TerminalNode
	NTILE() antlr.TerminalNode

	// IsNonAggregateWindowedFunctionContext differentiates from other interfaces.
	IsNonAggregateWindowedFunctionContext()
}

INonAggregateWindowedFunctionContext is an interface to support dynamic dispatch.

type INullCallClauseContext

type INullCallClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RETURNS() antlr.TerminalNode
	AllNULL_LITERAL() []antlr.TerminalNode
	NULL_LITERAL(i int) antlr.TerminalNode
	ON() antlr.TerminalNode
	INPUT() antlr.TerminalNode
	CALLED() antlr.TerminalNode

	// IsNullCallClauseContext differentiates from other interfaces.
	IsNullCallClauseContext()
}

INullCallClauseContext is an interface to support dynamic dispatch.

type INullLiteralContext

type INullLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NULL_LITERAL() antlr.TerminalNode

	// IsNullLiteralContext differentiates from other interfaces.
	IsNullLiteralContext()
}

INullLiteralContext is an interface to support dynamic dispatch.

type INullNotnullContext

type INullNotnullContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NULL_LITERAL() antlr.TerminalNode
	NOT() antlr.TerminalNode

	// IsNullNotnullContext differentiates from other interfaces.
	IsNullNotnullContext()
}

INullNotnullContext is an interface to support dynamic dispatch.

type INullTreatmentClauseContext

type INullTreatmentClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetNullTreatment returns the nullTreatment token.
	GetNullTreatment() antlr.Token

	// SetNullTreatment sets the nullTreatment token.
	SetNullTreatment(antlr.Token)

	// Getter signatures
	NULLS() antlr.TerminalNode
	IGNORE() antlr.TerminalNode
	RESPECT() antlr.TerminalNode

	// IsNullTreatmentClauseContext differentiates from other interfaces.
	IsNullTreatmentClauseContext()
}

INullTreatmentClauseContext is an interface to support dynamic dispatch.

type IOfTypeClauseContext

type IOfTypeClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	STRUCT() antlr.TerminalNode
	Uid() IUidContext

	// IsOfTypeClauseContext differentiates from other interfaces.
	IsOfTypeClauseContext()
}

IOfTypeClauseContext is an interface to support dynamic dispatch.

type IOptionContext

type IOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ENABLE_LONG_ROWS() antlr.TerminalNode
	EQUAL_SYMBOL() antlr.TerminalNode
	BooleanLiteral() IBooleanLiteralContext
	INTERMINGLE_TABLES() antlr.TerminalNode
	STORE_ROW_VERSIONS() antlr.TerminalNode

	// IsOptionContext differentiates from other interfaces.
	IsOptionContext()
}

IOptionContext is an interface to support dynamic dispatch.

type IOptionsClauseContext

type IOptionsClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WITH() antlr.TerminalNode
	OPTIONS() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllOption() []IOptionContext
	Option(i int) IOptionContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOptionsClauseContext differentiates from other interfaces.
	IsOptionsClauseContext()
}

IOptionsClauseContext is an interface to support dynamic dispatch.

type IOrderByClauseContext

type IOrderByClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ORDER() antlr.TerminalNode
	BY() antlr.TerminalNode
	AllOrderByExpression() []IOrderByExpressionContext
	OrderByExpression(i int) IOrderByExpressionContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsOrderByClauseContext differentiates from other interfaces.
	IsOrderByClauseContext()
}

IOrderByClauseContext is an interface to support dynamic dispatch.

type IOrderByExpressionContext

type IOrderByExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Expression() IExpressionContext
	OrderClause() IOrderClauseContext

	// IsOrderByExpressionContext differentiates from other interfaces.
	IsOrderByExpressionContext()
}

IOrderByExpressionContext is an interface to support dynamic dispatch.

type IOrderClauseContext

type IOrderClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOrder returns the order token.
	GetOrder() antlr.Token

	// GetNulls returns the nulls token.
	GetNulls() antlr.Token

	// SetOrder sets the order token.
	SetOrder(antlr.Token)

	// SetNulls sets the nulls token.
	SetNulls(antlr.Token)

	// Getter signatures
	ASC() antlr.TerminalNode
	DESC() antlr.TerminalNode
	NULLS() antlr.TerminalNode
	FIRST() antlr.TerminalNode
	LAST() antlr.TerminalNode

	// IsOrderClauseContext differentiates from other interfaces.
	IsOrderClauseContext()
}

IOrderClauseContext is an interface to support dynamic dispatch.

type IOverClauseContext

type IOverClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OVER() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	WindowSpec() IWindowSpecContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	WindowName() IWindowNameContext

	// IsOverClauseContext differentiates from other interfaces.
	IsOverClauseContext()
}

IOverClauseContext is an interface to support dynamic dispatch.

type IParameterModeContext

type IParameterModeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	IN() antlr.TerminalNode
	OUT() antlr.TerminalNode
	INOUT() antlr.TerminalNode

	// IsParameterModeContext differentiates from other interfaces.
	IsParameterModeContext()
}

IParameterModeContext is an interface to support dynamic dispatch.

type IParameterStyleContext

type IParameterStyleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PARAMETER() antlr.TerminalNode
	STYLE() antlr.TerminalNode
	SQL() antlr.TerminalNode
	GENERAL() antlr.TerminalNode

	// IsParameterStyleContext differentiates from other interfaces.
	IsParameterStyleContext()
}

IParameterStyleContext is an interface to support dynamic dispatch.

type IPartitionClauseContext

type IPartitionClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PARTITION() antlr.TerminalNode
	BY() antlr.TerminalNode
	AllFullId() []IFullIdContext
	FullId(i int) IFullIdContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsPartitionClauseContext differentiates from other interfaces.
	IsPartitionClauseContext()
}

IPartitionClauseContext is an interface to support dynamic dispatch.

type IPathContext

type IPathContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Uid() IUidContext

	// IsPathContext differentiates from other interfaces.
	IsPathContext()
}

IPathContext is an interface to support dynamic dispatch.

type IPredicateContext

type IPredicateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsPredicateContext differentiates from other interfaces.
	IsPredicateContext()
}

IPredicateContext is an interface to support dynamic dispatch.

type IPrepareStatementContext

type IPrepareStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetQueryString returns the queryString token.
	GetQueryString() antlr.Token

	// GetVariable returns the variable token.
	GetVariable() antlr.Token

	// SetQueryString sets the queryString token.
	SetQueryString(antlr.Token)

	// SetVariable sets the variable token.
	SetVariable(antlr.Token)

	// Getter signatures
	PREPARE() antlr.TerminalNode
	Uid() IUidContext
	FROM() antlr.TerminalNode
	STRING_LITERAL() antlr.TerminalNode
	LOCAL_ID() antlr.TerminalNode

	// IsPrepareStatementContext differentiates from other interfaces.
	IsPrepareStatementContext()
}

IPrepareStatementContext is an interface to support dynamic dispatch.

type IPreparedStatementContext

type IPreparedStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PrepareStatement() IPrepareStatementContext
	ExecuteStatement() IExecuteStatementContext

	// IsPreparedStatementContext differentiates from other interfaces.
	IsPreparedStatementContext()
}

IPreparedStatementContext is an interface to support dynamic dispatch.

type IPreparedStatementParameterContext

type IPreparedStatementParameterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	QUESTION() antlr.TerminalNode
	NAMED_PARAMETER() antlr.TerminalNode

	// IsPreparedStatementParameterContext differentiates from other interfaces.
	IsPreparedStatementParameterContext()
}

IPreparedStatementParameterContext is an interface to support dynamic dispatch.

type IPrimaryKeyDefinitionContext

type IPrimaryKeyDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	PRIMARY() antlr.TerminalNode
	KEY() antlr.TerminalNode
	FullIdList() IFullIdListContext
	SINGLE() antlr.TerminalNode
	ROW() antlr.TerminalNode
	ONLY() antlr.TerminalNode

	// IsPrimaryKeyDefinitionContext differentiates from other interfaces.
	IsPrimaryKeyDefinitionContext()
}

IPrimaryKeyDefinitionContext is an interface to support dynamic dispatch.

type IPrimitiveTypeContext

type IPrimitiveTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	BOOLEAN() antlr.TerminalNode
	INTEGER() antlr.TerminalNode
	BIGINT() antlr.TerminalNode
	FLOAT() antlr.TerminalNode
	DOUBLE() antlr.TerminalNode
	STRING() antlr.TerminalNode
	BYTES() antlr.TerminalNode
	UUID() antlr.TerminalNode
	DATE() antlr.TerminalNode
	TIMESTAMP() antlr.TerminalNode
	VectorType() IVectorTypeContext

	// IsPrimitiveTypeContext differentiates from other interfaces.
	IsPrimitiveTypeContext()
}

IPrimitiveTypeContext is an interface to support dynamic dispatch.

type IQualifyClauseContext

type IQualifyClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	QUALIFY() antlr.TerminalNode
	Expression() IExpressionContext

	// IsQualifyClauseContext differentiates from other interfaces.
	IsQualifyClauseContext()
}

IQualifyClauseContext is an interface to support dynamic dispatch.

type IQueryContext

type IQueryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	QueryExpressionBody() IQueryExpressionBodyContext
	Ctes() ICtesContext

	// IsQueryContext differentiates from other interfaces.
	IsQueryContext()
}

IQueryContext is an interface to support dynamic dispatch.

type IQueryExpressionBodyContext

type IQueryExpressionBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsQueryExpressionBodyContext differentiates from other interfaces.
	IsQueryExpressionBodyContext()
}

IQueryExpressionBodyContext is an interface to support dynamic dispatch.

type IQueryTermContext

type IQueryTermContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsQueryTermContext differentiates from other interfaces.
	IsQueryTermContext()
}

IQueryTermContext is an interface to support dynamic dispatch.

type IRecordConstructorContext

type IRecordConstructorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	Uid() IUidContext
	DOT() antlr.TerminalNode
	STAR() antlr.TerminalNode
	AllExpressionWithOptionalName() []IExpressionWithOptionalNameContext
	ExpressionWithOptionalName(i int) IExpressionWithOptionalNameContext
	OfTypeClause() IOfTypeClauseContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsRecordConstructorContext differentiates from other interfaces.
	IsRecordConstructorContext()
}

IRecordConstructorContext is an interface to support dynamic dispatch.

type IRecordConstructorForInlineTableContext

type IRecordConstructorForInlineTableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllExpressionWithOptionalName() []IExpressionWithOptionalNameContext
	ExpressionWithOptionalName(i int) IExpressionWithOptionalNameContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsRecordConstructorForInlineTableContext differentiates from other interfaces.
	IsRecordConstructorForInlineTableContext()
}

IRecordConstructorForInlineTableContext is an interface to support dynamic dispatch.

type IRecordConstructorForInsertContext

type IRecordConstructorForInsertContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllExpressionWithOptionalName() []IExpressionWithOptionalNameContext
	ExpressionWithOptionalName(i int) IExpressionWithOptionalNameContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsRecordConstructorForInsertContext differentiates from other interfaces.
	IsRecordConstructorForInsertContext()
}

IRecordConstructorForInsertContext is an interface to support dynamic dispatch.

type IResetStatementContext

type IResetStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RESET() antlr.TerminalNode
	QUERY() antlr.TerminalNode
	CACHE() antlr.TerminalNode

	// IsResetStatementContext differentiates from other interfaces.
	IsResetStatementContext()
}

IResetStatementContext is an interface to support dynamic dispatch.

type IReturnsClauseContext

type IReturnsClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RETURNS() antlr.TerminalNode
	ReturnsType() IReturnsTypeContext

	// IsReturnsClauseContext differentiates from other interfaces.
	IsReturnsClauseContext()
}

IReturnsClauseContext is an interface to support dynamic dispatch.

type IReturnsTableTypeContext

type IReturnsTableTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TABLE() antlr.TerminalNode
	TableFunctionColumnList() ITableFunctionColumnListContext

	// IsReturnsTableTypeContext differentiates from other interfaces.
	IsReturnsTableTypeContext()
}

IReturnsTableTypeContext is an interface to support dynamic dispatch.

type IReturnsTypeContext

type IReturnsTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetReturnsDataType returns the returnsDataType rule contexts.
	GetReturnsDataType() IColumnTypeContext

	// SetReturnsDataType sets the returnsDataType rule contexts.
	SetReturnsDataType(IColumnTypeContext)

	// Getter signatures
	ColumnType() IColumnTypeContext
	ARRAY() antlr.TerminalNode
	ReturnsTableType() IReturnsTableTypeContext

	// IsReturnsTypeContext differentiates from other interfaces.
	IsReturnsTypeContext()
}

IReturnsTypeContext is an interface to support dynamic dispatch.

type IRollbackStatementContext

type IRollbackStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ROLLBACK() antlr.TerminalNode

	// IsRollbackStatementContext differentiates from other interfaces.
	IsRollbackStatementContext()
}

IRollbackStatementContext is an interface to support dynamic dispatch.

type IRootContext

type IRootContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EOF() antlr.TerminalNode
	Statements() IStatementsContext
	AllMINUS() []antlr.TerminalNode
	MINUS(i int) antlr.TerminalNode

	// IsRootContext differentiates from other interfaces.
	IsRootContext()
}

IRootContext is an interface to support dynamic dispatch.

type IRoutineBodyContext

type IRoutineBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsRoutineBodyContext differentiates from other interfaces.
	IsRoutineBodyContext()
}

IRoutineBodyContext is an interface to support dynamic dispatch.

type IRoutineCharacteristicsContext

type IRoutineCharacteristicsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LanguageClause() ILanguageClauseContext
	ParameterStyle() IParameterStyleContext
	DeterministicCharacteristic() IDeterministicCharacteristicContext
	NullCallClause() INullCallClauseContext

	// IsRoutineCharacteristicsContext differentiates from other interfaces.
	IsRoutineCharacteristicsContext()
}

IRoutineCharacteristicsContext is an interface to support dynamic dispatch.

type IScalarFunctionNameContext

type IScalarFunctionNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FunctionNameBase() IFunctionNameBaseContext
	FunctionNameKeyword() IFunctionNameKeywordContext
	ASCII() antlr.TerminalNode
	CURDATE() antlr.TerminalNode
	CURRENT_DATE() antlr.TerminalNode
	CURRENT_TIME() antlr.TerminalNode
	CURRENT_TIMESTAMP() antlr.TerminalNode
	CURTIME() antlr.TerminalNode
	DATE_ADD() antlr.TerminalNode
	DATE_SUB() antlr.TerminalNode
	IF() antlr.TerminalNode
	INSERT() antlr.TerminalNode
	LOCALTIME() antlr.TerminalNode
	LOCALTIMESTAMP() antlr.TerminalNode
	MID() antlr.TerminalNode
	NOW() antlr.TerminalNode
	REPLACE() antlr.TerminalNode
	SUBSTR() antlr.TerminalNode
	SUBSTRING() antlr.TerminalNode
	SYSDATE() antlr.TerminalNode
	TRIM() antlr.TerminalNode
	UTC_DATE() antlr.TerminalNode
	UTC_TIME() antlr.TerminalNode
	UTC_TIMESTAMP() antlr.TerminalNode
	JAVA_CALL() antlr.TerminalNode

	// IsScalarFunctionNameContext differentiates from other interfaces.
	IsScalarFunctionNameContext()
}

IScalarFunctionNameContext is an interface to support dynamic dispatch.

type ISchemaIdContext

type ISchemaIdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Path() IPathContext

	// IsSchemaIdContext differentiates from other interfaces.
	IsSchemaIdContext()
}

ISchemaIdContext is an interface to support dynamic dispatch.

type ISchemaTemplateIdContext

type ISchemaTemplateIdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Uid() IUidContext

	// IsSchemaTemplateIdContext differentiates from other interfaces.
	IsSchemaTemplateIdContext()
}

ISchemaTemplateIdContext is an interface to support dynamic dispatch.

type ISelectElementContext

type ISelectElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsSelectElementContext differentiates from other interfaces.
	IsSelectElementContext()
}

ISelectElementContext is an interface to support dynamic dispatch.

type ISelectElementsContext

type ISelectElementsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSelectElement() []ISelectElementContext
	SelectElement(i int) ISelectElementContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsSelectElementsContext differentiates from other interfaces.
	IsSelectElementsContext()
}

ISelectElementsContext is an interface to support dynamic dispatch.

type ISelectStatementContext

type ISelectStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Query() IQueryContext
	StatementOptions() IStatementOptionsContext

	// IsSelectStatementContext differentiates from other interfaces.
	IsSelectStatementContext()
}

ISelectStatementContext is an interface to support dynamic dispatch.

type ISetAutocommitStatementContext

type ISetAutocommitStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAutocommitValue returns the autocommitValue token.
	GetAutocommitValue() antlr.Token

	// SetAutocommitValue sets the autocommitValue token.
	SetAutocommitValue(antlr.Token)

	// Getter signatures
	SET() antlr.TerminalNode
	AUTOCOMMIT() antlr.TerminalNode
	EQUAL_SYMBOL() antlr.TerminalNode
	ON() antlr.TerminalNode
	OFF() antlr.TerminalNode

	// IsSetAutocommitStatementContext differentiates from other interfaces.
	IsSetAutocommitStatementContext()
}

ISetAutocommitStatementContext is an interface to support dynamic dispatch.

type ISetStatementContext

type ISetStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsSetStatementContext differentiates from other interfaces.
	IsSetStatementContext()
}

ISetStatementContext is an interface to support dynamic dispatch.

type ISetTransactionStatementContext

type ISetTransactionStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetTransactionContext returns the transactionContext token.
	GetTransactionContext() antlr.Token

	// SetTransactionContext sets the transactionContext token.
	SetTransactionContext(antlr.Token)

	// Getter signatures
	SET() antlr.TerminalNode
	TRANSACTION() antlr.TerminalNode
	AllTransactionOption() []ITransactionOptionContext
	TransactionOption(i int) ITransactionOptionContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode
	GLOBAL() antlr.TerminalNode
	SESSION() antlr.TerminalNode

	// IsSetTransactionStatementContext differentiates from other interfaces.
	IsSetTransactionStatementContext()
}

ISetTransactionStatementContext is an interface to support dynamic dispatch.

type IShowStatementContext

type IShowStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsShowStatementContext differentiates from other interfaces.
	IsShowStatementContext()
}

IShowStatementContext is an interface to support dynamic dispatch.

type ISimpleDescribeStatementContext

type ISimpleDescribeStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsSimpleDescribeStatementContext differentiates from other interfaces.
	IsSimpleDescribeStatementContext()
}

ISimpleDescribeStatementContext is an interface to support dynamic dispatch.

type ISimpleIdContext

type ISimpleIdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ID() antlr.TerminalNode
	CharsetNameBase() ICharsetNameBaseContext
	IntervalTypeBase() IIntervalTypeBaseContext
	KeywordsCanBeId() IKeywordsCanBeIdContext
	FunctionNameBase() IFunctionNameBaseContext

	// IsSimpleIdContext differentiates from other interfaces.
	IsSimpleIdContext()
}

ISimpleIdContext is an interface to support dynamic dispatch.

type ISpecificFunctionContext

type ISpecificFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsSpecificFunctionContext differentiates from other interfaces.
	IsSpecificFunctionContext()
}

ISpecificFunctionContext is an interface to support dynamic dispatch.

type ISqlInvokedFunctionContext

type ISqlInvokedFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FunctionSpecification() IFunctionSpecificationContext
	RoutineBody() IRoutineBodyContext

	// IsSqlInvokedFunctionContext differentiates from other interfaces.
	IsSqlInvokedFunctionContext()
}

ISqlInvokedFunctionContext is an interface to support dynamic dispatch.

type ISqlParameterDeclarationContext

type ISqlParameterDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSqlParameterName returns the sqlParameterName rule contexts.
	GetSqlParameterName() IUidContext

	// GetParameterType returns the parameterType rule contexts.
	GetParameterType() IFunctionColumnTypeContext

	// GetParameterDefault returns the parameterDefault rule contexts.
	GetParameterDefault() IExpressionContext

	// SetSqlParameterName sets the sqlParameterName rule contexts.
	SetSqlParameterName(IUidContext)

	// SetParameterType sets the parameterType rule contexts.
	SetParameterType(IFunctionColumnTypeContext)

	// SetParameterDefault sets the parameterDefault rule contexts.
	SetParameterDefault(IExpressionContext)

	// Getter signatures
	FunctionColumnType() IFunctionColumnTypeContext
	ParameterMode() IParameterModeContext
	DEFAULT() antlr.TerminalNode
	Uid() IUidContext
	Expression() IExpressionContext

	// IsSqlParameterDeclarationContext differentiates from other interfaces.
	IsSqlParameterDeclarationContext()
}

ISqlParameterDeclarationContext is an interface to support dynamic dispatch.

type ISqlParameterDeclarationListContext

type ISqlParameterDeclarationListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	SqlParameterDeclarations() ISqlParameterDeclarationsContext

	// IsSqlParameterDeclarationListContext differentiates from other interfaces.
	IsSqlParameterDeclarationListContext()
}

ISqlParameterDeclarationListContext is an interface to support dynamic dispatch.

type ISqlParameterDeclarationsContext

type ISqlParameterDeclarationsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSqlParameterDeclaration() []ISqlParameterDeclarationContext
	SqlParameterDeclaration(i int) ISqlParameterDeclarationContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsSqlParameterDeclarationsContext differentiates from other interfaces.
	IsSqlParameterDeclarationsContext()
}

ISqlParameterDeclarationsContext is an interface to support dynamic dispatch.

type IStartTransactionContext

type IStartTransactionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	START() antlr.TerminalNode
	TRANSACTION() antlr.TerminalNode

	// IsStartTransactionContext differentiates from other interfaces.
	IsStartTransactionContext()
}

IStartTransactionContext is an interface to support dynamic dispatch.

type IStatementContext

type IStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SelectStatement() ISelectStatementContext
	DdlStatement() IDdlStatementContext
	DmlStatement() IDmlStatementContext
	TransactionStatement() ITransactionStatementContext
	PreparedStatement() IPreparedStatementContext
	AdministrationStatement() IAdministrationStatementContext
	UtilityStatement() IUtilityStatementContext

	// IsStatementContext differentiates from other interfaces.
	IsStatementContext()
}

IStatementContext is an interface to support dynamic dispatch.

type IStatementOptionContext

type IStatementOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	NOCACHE() antlr.TerminalNode
	LOG() antlr.TerminalNode
	QUERY() antlr.TerminalNode
	DRY() antlr.TerminalNode
	RUN() antlr.TerminalNode
	PLAN() antlr.TerminalNode
	RIGHT() antlr.TerminalNode
	DEEP() antlr.TerminalNode
	ISOLATION() antlr.TerminalNode
	LEVEL() antlr.TerminalNode
	SNAPSHOT() antlr.TerminalNode

	// IsStatementOptionContext differentiates from other interfaces.
	IsStatementOptionContext()
}

IStatementOptionContext is an interface to support dynamic dispatch.

type IStatementOptionsContext

type IStatementOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPTIONS() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllStatementOption() []IStatementOptionContext
	StatementOption(i int) IStatementOptionContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsStatementOptionsContext differentiates from other interfaces.
	IsStatementOptionsContext()
}

IStatementOptionsContext is an interface to support dynamic dispatch.

type IStatementsContext

type IStatementsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllStatement() []IStatementContext
	Statement(i int) IStatementContext
	AllSEMI() []antlr.TerminalNode
	SEMI(i int) antlr.TerminalNode

	// IsStatementsContext differentiates from other interfaces.
	IsStatementsContext()
}

IStatementsContext is an interface to support dynamic dispatch.

type IStoredQueryDefinitionContext

type IStoredQueryDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetQueryName returns the queryName rule contexts.
	GetQueryName() IUidContext

	// GetStoredQuery returns the storedQuery rule contexts.
	GetStoredQuery() IQueryContext

	// SetQueryName sets the queryName rule contexts.
	SetQueryName(IUidContext)

	// SetStoredQuery sets the storedQuery rule contexts.
	SetStoredQuery(IQueryContext)

	// Getter signatures
	STORED() antlr.TerminalNode
	QUERY() antlr.TerminalNode
	AS() antlr.TerminalNode
	Uid() IUidContext
	Query() IQueryContext
	DeclareBlock() IDeclareBlockContext

	// IsStoredQueryDefinitionContext differentiates from other interfaces.
	IsStoredQueryDefinitionContext()
}

IStoredQueryDefinitionContext is an interface to support dynamic dispatch.

type IStringLiteralContext

type IStringLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllSTRING_LITERAL() []antlr.TerminalNode
	STRING_LITERAL(i int) antlr.TerminalNode
	START_NATIONAL_STRING_LITERAL() antlr.TerminalNode
	STRING_CHARSET_NAME() antlr.TerminalNode
	COLLATE() antlr.TerminalNode
	CollationName() ICollationNameContext

	// IsStringLiteralContext differentiates from other interfaces.
	IsStringLiteralContext()
}

IStringLiteralContext is an interface to support dynamic dispatch.

type IStructDefinitionContext

type IStructDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Uid() IUidContext
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllColumnDefinition() []IColumnDefinitionContext
	ColumnDefinition(i int) IColumnDefinitionContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	TYPE() antlr.TerminalNode
	AS() antlr.TerminalNode
	STRUCT() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsStructDefinitionContext differentiates from other interfaces.
	IsStructDefinitionContext()
}

IStructDefinitionContext is an interface to support dynamic dispatch.

type ITableDefinitionContext

type ITableDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TABLE() antlr.TerminalNode
	Uid() IUidContext
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllColumnDefinition() []IColumnDefinitionContext
	ColumnDefinition(i int) IColumnDefinitionContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode
	PrimaryKeyDefinition() IPrimaryKeyDefinitionContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode

	// IsTableDefinitionContext differentiates from other interfaces.
	IsTableDefinitionContext()
}

ITableDefinitionContext is an interface to support dynamic dispatch.

type ITableFunctionColumnListContext

type ITableFunctionColumnListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllTableFunctionColumnListElement() []ITableFunctionColumnListElementContext
	TableFunctionColumnListElement(i int) ITableFunctionColumnListElementContext

	// IsTableFunctionColumnListContext differentiates from other interfaces.
	IsTableFunctionColumnListContext()
}

ITableFunctionColumnListContext is an interface to support dynamic dispatch.

type ITableFunctionColumnListElementContext

type ITableFunctionColumnListElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetColumnName returns the columnName rule contexts.
	GetColumnName() IUidContext

	// GetColumnDataType returns the columnDataType rule contexts.
	GetColumnDataType() IColumnTypeContext

	// SetColumnName sets the columnName rule contexts.
	SetColumnName(IUidContext)

	// SetColumnDataType sets the columnDataType rule contexts.
	SetColumnDataType(IColumnTypeContext)

	// Getter signatures
	Uid() IUidContext
	ColumnType() IColumnTypeContext

	// IsTableFunctionColumnListElementContext differentiates from other interfaces.
	IsTableFunctionColumnListElementContext()
}

ITableFunctionColumnListElementContext is an interface to support dynamic dispatch.

type ITableFunctionContext

type ITableFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	TableFunctionName() ITableFunctionNameContext
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	NamedOrUnnamedFunctionArgs() INamedOrUnnamedFunctionArgsContext
	InlineTableDefinition() IInlineTableDefinitionContext

	// IsTableFunctionContext differentiates from other interfaces.
	IsTableFunctionContext()
}

ITableFunctionContext is an interface to support dynamic dispatch.

type ITableFunctionNameContext

type ITableFunctionNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FullId() IFullIdContext

	// IsTableFunctionNameContext differentiates from other interfaces.
	IsTableFunctionNameContext()
}

ITableFunctionNameContext is an interface to support dynamic dispatch.

type ITableIndexesContext

type ITableIndexesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetIndexFormat returns the indexFormat token.
	GetIndexFormat() antlr.Token

	// SetIndexFormat sets the indexFormat token.
	SetIndexFormat(antlr.Token)

	// Getter signatures
	TableName() ITableNameContext
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	UidList() IUidListContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	INDEX() antlr.TerminalNode
	KEY() antlr.TerminalNode

	// IsTableIndexesContext differentiates from other interfaces.
	IsTableIndexesContext()
}

ITableIndexesContext is an interface to support dynamic dispatch.

type ITableNameContext

type ITableNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FullId() IFullIdContext

	// IsTableNameContext differentiates from other interfaces.
	IsTableNameContext()
}

ITableNameContext is an interface to support dynamic dispatch.

type ITableSourceContext

type ITableSourceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsTableSourceContext differentiates from other interfaces.
	IsTableSourceContext()
}

ITableSourceContext is an interface to support dynamic dispatch.

type ITableSourceItemContext

type ITableSourceItemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser
	// IsTableSourceItemContext differentiates from other interfaces.
	IsTableSourceItemContext()
}

ITableSourceItemContext is an interface to support dynamic dispatch.

type ITableSourcesContext

type ITableSourcesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTableSource() []ITableSourceContext
	TableSource(i int) ITableSourceContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsTableSourcesContext differentiates from other interfaces.
	IsTableSourcesContext()
}

ITableSourcesContext is an interface to support dynamic dispatch.

type ITablesContext

type ITablesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllTableName() []ITableNameContext
	TableName(i int) ITableNameContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsTablesContext differentiates from other interfaces.
	IsTablesContext()
}

ITablesContext is an interface to support dynamic dispatch.

type ITempSqlInvokedFunctionContext

type ITempSqlInvokedFunctionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FunctionSpecification() IFunctionSpecificationContext
	ON() antlr.TerminalNode
	COMMIT() antlr.TerminalNode
	DROP() antlr.TerminalNode
	FUNCTION() antlr.TerminalNode
	RoutineBody() IRoutineBodyContext

	// IsTempSqlInvokedFunctionContext differentiates from other interfaces.
	IsTempSqlInvokedFunctionContext()
}

ITempSqlInvokedFunctionContext is an interface to support dynamic dispatch.

type ITemplateClauseContext

type ITemplateClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	CREATE() antlr.TerminalNode
	StructDefinition() IStructDefinitionContext
	TableDefinition() ITableDefinitionContext
	EnumDefinition() IEnumDefinitionContext
	IndexDefinition() IIndexDefinitionContext
	SqlInvokedFunction() ISqlInvokedFunctionContext
	ViewDefinition() IViewDefinitionContext
	StoredQueryDefinition() IStoredQueryDefinitionContext

	// IsTemplateClauseContext differentiates from other interfaces.
	IsTemplateClauseContext()
}

ITemplateClauseContext is an interface to support dynamic dispatch.

type ITransactionLevelContext

type ITransactionLevelContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	READ() antlr.TerminalNode
	COMMITTED() antlr.TerminalNode
	SERIALIZABLE() antlr.TerminalNode

	// IsTransactionLevelContext differentiates from other interfaces.
	IsTransactionLevelContext()
}

ITransactionLevelContext is an interface to support dynamic dispatch.

type ITransactionOptionContext

type ITransactionOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ISOLATION() antlr.TerminalNode
	LEVEL() antlr.TerminalNode
	TransactionLevel() ITransactionLevelContext

	// IsTransactionOptionContext differentiates from other interfaces.
	IsTransactionOptionContext()
}

ITransactionOptionContext is an interface to support dynamic dispatch.

type ITransactionStatementContext

type ITransactionStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	StartTransaction() IStartTransactionContext
	CommitStatement() ICommitStatementContext
	RollbackStatement() IRollbackStatementContext

	// IsTransactionStatementContext differentiates from other interfaces.
	IsTransactionStatementContext()
}

ITransactionStatementContext is an interface to support dynamic dispatch.

type ITraversalOrderClauseContext

type ITraversalOrderClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOrder returns the order token.
	GetOrder() antlr.Token

	// SetOrder sets the order token.
	SetOrder(antlr.Token)

	// Getter signatures
	TRAVERSAL() antlr.TerminalNode
	ORDER() antlr.TerminalNode
	PRE_ORDER() antlr.TerminalNode
	LEVEL_ORDER() antlr.TerminalNode
	POST_ORDER() antlr.TerminalNode

	// IsTraversalOrderClauseContext differentiates from other interfaces.
	IsTraversalOrderClauseContext()
}

ITraversalOrderClauseContext is an interface to support dynamic dispatch.

type IUidContext

type IUidContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SimpleId() ISimpleIdContext
	DOUBLE_QUOTE_ID() antlr.TerminalNode

	// IsUidContext differentiates from other interfaces.
	IsUidContext()
}

IUidContext is an interface to support dynamic dispatch.

type IUidListContext

type IUidListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllUid() []IUidContext
	Uid(i int) IUidContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsUidListContext differentiates from other interfaces.
	IsUidListContext()
}

IUidListContext is an interface to support dynamic dispatch.

type IUidListWithNestingsContext

type IUidListWithNestingsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllUidWithNestings() []IUidWithNestingsContext
	UidWithNestings(i int) IUidWithNestingsContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsUidListWithNestingsContext differentiates from other interfaces.
	IsUidListWithNestingsContext()
}

IUidListWithNestingsContext is an interface to support dynamic dispatch.

type IUidListWithNestingsInParensContext

type IUidListWithNestingsInParensContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	UidListWithNestings() IUidListWithNestingsContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode

	// IsUidListWithNestingsInParensContext differentiates from other interfaces.
	IsUidListWithNestingsInParensContext()
}

IUidListWithNestingsInParensContext is an interface to support dynamic dispatch.

type IUidWithNestingsContext

type IUidWithNestingsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Uid() IUidContext
	UidListWithNestingsInParens() IUidListWithNestingsInParensContext

	// IsUidWithNestingsContext differentiates from other interfaces.
	IsUidWithNestingsContext()
}

IUidWithNestingsContext is an interface to support dynamic dispatch.

type IUnaryOperatorContext

type IUnaryOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	EXCLAMATION_SYMBOL() antlr.TerminalNode
	BIT_NOT_OP() antlr.TerminalNode
	PLUS() antlr.TerminalNode
	MINUS() antlr.TerminalNode
	NOT() antlr.TerminalNode

	// IsUnaryOperatorContext differentiates from other interfaces.
	IsUnaryOperatorContext()
}

IUnaryOperatorContext is an interface to support dynamic dispatch.

type IUpdateStatementContext

type IUpdateStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	UPDATE() antlr.TerminalNode
	TableName() ITableNameContext
	SET() antlr.TerminalNode
	AllUpdatedElement() []IUpdatedElementContext
	UpdatedElement(i int) IUpdatedElementContext
	Uid() IUidContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode
	WHERE() antlr.TerminalNode
	WhereExpr() IWhereExprContext
	RETURNING() antlr.TerminalNode
	SelectElements() ISelectElementsContext
	StatementOptions() IStatementOptionsContext
	AS() antlr.TerminalNode

	// IsUpdateStatementContext differentiates from other interfaces.
	IsUpdateStatementContext()
}

IUpdateStatementContext is an interface to support dynamic dispatch.

type IUpdatedElementContext

type IUpdatedElementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FullColumnName() IFullColumnNameContext
	EQUAL_SYMBOL() antlr.TerminalNode
	Expression() IExpressionContext
	DEFAULT() antlr.TerminalNode

	// IsUpdatedElementContext differentiates from other interfaces.
	IsUpdatedElementContext()
}

IUpdatedElementContext is an interface to support dynamic dispatch.

type IUserDefinedScalarFunctionNameContext

type IUserDefinedScalarFunctionNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	ID() antlr.TerminalNode
	DOUBLE_QUOTE_ID() antlr.TerminalNode

	// IsUserDefinedScalarFunctionNameContext differentiates from other interfaces.
	IsUserDefinedScalarFunctionNameContext()
}

IUserDefinedScalarFunctionNameContext is an interface to support dynamic dispatch.

type IUserVariablesContext

type IUserVariablesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	AllLOCAL_ID() []antlr.TerminalNode
	LOCAL_ID(i int) antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsUserVariablesContext differentiates from other interfaces.
	IsUserVariablesContext()
}

IUserVariablesContext is an interface to support dynamic dispatch.

type IUtilityStatementContext

type IUtilityStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	SimpleDescribeStatement() ISimpleDescribeStatementContext
	FullDescribeStatement() IFullDescribeStatementContext
	HelpStatement() IHelpStatementContext

	// IsUtilityStatementContext differentiates from other interfaces.
	IsUtilityStatementContext()
}

IUtilityStatementContext is an interface to support dynamic dispatch.

type IVariableClauseContext

type IVariableClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	LOCAL_ID() antlr.TerminalNode
	Uid() IUidContext
	GLOBAL() antlr.TerminalNode
	SESSION() antlr.TerminalNode
	LOCAL() antlr.TerminalNode
	AllAT_SIGN() []antlr.TerminalNode
	AT_SIGN(i int) antlr.TerminalNode

	// IsVariableClauseContext differentiates from other interfaces.
	IsVariableClauseContext()
}

IVariableClauseContext is an interface to support dynamic dispatch.

type IVectorElementTypeContext

type IVectorElementTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	FLOAT() antlr.TerminalNode
	DOUBLE() antlr.TerminalNode
	HALF() antlr.TerminalNode

	// IsVectorElementTypeContext differentiates from other interfaces.
	IsVectorElementTypeContext()
}

IVectorElementTypeContext is an interface to support dynamic dispatch.

type IVectorEngineContext

type IVectorEngineContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	HNSW() antlr.TerminalNode
	GUARDIANN() antlr.TerminalNode
	SPFRESH() antlr.TerminalNode

	// IsVectorEngineContext differentiates from other interfaces.
	IsVectorEngineContext()
}

IVectorEngineContext is an interface to support dynamic dispatch.

type IVectorIndexOptionContext

type IVectorIndexOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOptionName returns the optionName rule contexts.
	GetOptionName() ISimpleIdContext

	// GetOptionValue returns the optionValue rule contexts.
	GetOptionValue() IVectorIndexOptionValueContext

	// SetOptionName sets the optionName rule contexts.
	SetOptionName(ISimpleIdContext)

	// SetOptionValue sets the optionValue rule contexts.
	SetOptionValue(IVectorIndexOptionValueContext)

	// Getter signatures
	EQUAL_SYMBOL() antlr.TerminalNode
	SimpleId() ISimpleIdContext
	VectorIndexOptionValue() IVectorIndexOptionValueContext

	// IsVectorIndexOptionContext differentiates from other interfaces.
	IsVectorIndexOptionContext()
}

IVectorIndexOptionContext is an interface to support dynamic dispatch.

type IVectorIndexOptionValueContext

type IVectorIndexOptionValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	DECIMAL_LITERAL() antlr.TerminalNode
	REAL_LITERAL() antlr.TerminalNode
	BooleanLiteral() IBooleanLiteralContext
	HnswMetric() IHnswMetricContext

	// IsVectorIndexOptionValueContext differentiates from other interfaces.
	IsVectorIndexOptionValueContext()
}

IVectorIndexOptionValueContext is an interface to support dynamic dispatch.

type IVectorIndexOptionsContext

type IVectorIndexOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPTIONS() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllVectorIndexOption() []IVectorIndexOptionContext
	VectorIndexOption(i int) IVectorIndexOptionContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsVectorIndexOptionsContext differentiates from other interfaces.
	IsVectorIndexOptionsContext()
}

IVectorIndexOptionsContext is an interface to support dynamic dispatch.

type IVectorTypeContext

type IVectorTypeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDimensions returns the dimensions token.
	GetDimensions() antlr.Token

	// SetDimensions sets the dimensions token.
	SetDimensions(antlr.Token)

	// GetElementType returns the elementType rule contexts.
	GetElementType() IVectorElementTypeContext

	// SetElementType sets the elementType rule contexts.
	SetElementType(IVectorElementTypeContext)

	// Getter signatures
	VECTOR() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	COMMA() antlr.TerminalNode
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	DECIMAL_LITERAL() antlr.TerminalNode
	VectorElementType() IVectorElementTypeContext

	// IsVectorTypeContext differentiates from other interfaces.
	IsVectorTypeContext()
}

IVectorTypeContext is an interface to support dynamic dispatch.

type IViewDefinitionContext

type IViewDefinitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetViewName returns the viewName rule contexts.
	GetViewName() IFullIdContext

	// GetViewQuery returns the viewQuery rule contexts.
	GetViewQuery() IQueryContext

	// SetViewName sets the viewName rule contexts.
	SetViewName(IFullIdContext)

	// SetViewQuery sets the viewQuery rule contexts.
	SetViewQuery(IQueryContext)

	// Getter signatures
	VIEW() antlr.TerminalNode
	AS() antlr.TerminalNode
	FullId() IFullIdContext
	Query() IQueryContext

	// IsViewDefinitionContext differentiates from other interfaces.
	IsViewDefinitionContext()
}

IViewDefinitionContext is an interface to support dynamic dispatch.

type IWhereExprContext

type IWhereExprContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Expression() IExpressionContext

	// IsWhereExprContext differentiates from other interfaces.
	IsWhereExprContext()
}

IWhereExprContext is an interface to support dynamic dispatch.

type IWindowNameContext

type IWindowNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Uid() IUidContext

	// IsWindowNameContext differentiates from other interfaces.
	IsWindowNameContext()
}

IWindowNameContext is an interface to support dynamic dispatch.

type IWindowOptionContext

type IWindowOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetEfSearch returns the efSearch token.
	GetEfSearch() antlr.Token

	// SetEfSearch sets the efSearch token.
	SetEfSearch(antlr.Token)

	// Getter signatures
	EF_SEARCH() antlr.TerminalNode
	EQUAL_SYMBOL() antlr.TerminalNode
	DECIMAL_LITERAL() antlr.TerminalNode

	// IsWindowOptionContext differentiates from other interfaces.
	IsWindowOptionContext()
}

IWindowOptionContext is an interface to support dynamic dispatch.

type IWindowOptionsClauseContext

type IWindowOptionsClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPTIONS() antlr.TerminalNode
	AllWindowOption() []IWindowOptionContext
	WindowOption(i int) IWindowOptionContext
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsWindowOptionsClauseContext differentiates from other interfaces.
	IsWindowOptionsClauseContext()
}

IWindowOptionsClauseContext is an interface to support dynamic dispatch.

type IWindowSpecContext

type IWindowSpecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	WindowName() IWindowNameContext
	PartitionClause() IPartitionClauseContext
	OrderByClause() IOrderByClauseContext
	WindowOptionsClause() IWindowOptionsClauseContext

	// IsWindowSpecContext differentiates from other interfaces.
	IsWindowSpecContext()
}

IWindowSpecContext is an interface to support dynamic dispatch.

type IfExistsContext

type IfExistsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIfExistsContext

func NewEmptyIfExistsContext() *IfExistsContext

func NewIfExistsContext

func NewIfExistsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfExistsContext

func (*IfExistsContext) Accept

func (s *IfExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IfExistsContext) EXISTS

func (s *IfExistsContext) EXISTS() antlr.TerminalNode

func (*IfExistsContext) EnterRule

func (s *IfExistsContext) EnterRule(listener antlr.ParseTreeListener)

func (*IfExistsContext) ExitRule

func (s *IfExistsContext) ExitRule(listener antlr.ParseTreeListener)

func (*IfExistsContext) GetParser

func (s *IfExistsContext) GetParser() antlr.Parser

func (*IfExistsContext) GetRuleContext

func (s *IfExistsContext) GetRuleContext() antlr.RuleContext

func (*IfExistsContext) IF

func (*IfExistsContext) IsIfExistsContext

func (*IfExistsContext) IsIfExistsContext()

func (*IfExistsContext) ToStringTree

func (s *IfExistsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IfNotExistsContext

type IfNotExistsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIfNotExistsContext

func NewEmptyIfNotExistsContext() *IfNotExistsContext

func NewIfNotExistsContext

func NewIfNotExistsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IfNotExistsContext

func (*IfNotExistsContext) Accept

func (s *IfNotExistsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IfNotExistsContext) EXISTS

func (*IfNotExistsContext) EnterRule

func (s *IfNotExistsContext) EnterRule(listener antlr.ParseTreeListener)

func (*IfNotExistsContext) ExitRule

func (s *IfNotExistsContext) ExitRule(listener antlr.ParseTreeListener)

func (*IfNotExistsContext) GetParser

func (s *IfNotExistsContext) GetParser() antlr.Parser

func (*IfNotExistsContext) GetRuleContext

func (s *IfNotExistsContext) GetRuleContext() antlr.RuleContext

func (*IfNotExistsContext) IF

func (*IfNotExistsContext) IsIfNotExistsContext

func (*IfNotExistsContext) IsIfNotExistsContext()

func (*IfNotExistsContext) NOT

func (*IfNotExistsContext) ToStringTree

func (s *IfNotExistsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type InListContext

type InListContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyInListContext

func NewEmptyInListContext() *InListContext

func NewInListContext

func NewInListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InListContext

func (*InListContext) Accept

func (s *InListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InListContext) EnterRule

func (s *InListContext) EnterRule(listener antlr.ParseTreeListener)

func (*InListContext) ExitRule

func (s *InListContext) ExitRule(listener antlr.ParseTreeListener)

func (*InListContext) Expressions

func (s *InListContext) Expressions() IExpressionsContext

func (*InListContext) FullColumnName

func (s *InListContext) FullColumnName() IFullColumnNameContext

func (*InListContext) GetParser

func (s *InListContext) GetParser() antlr.Parser

func (*InListContext) GetRuleContext

func (s *InListContext) GetRuleContext() antlr.RuleContext

func (*InListContext) IsInListContext

func (*InListContext) IsInListContext()

func (*InListContext) LEFT_ROUND_BRACKET

func (s *InListContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*InListContext) PreparedStatementParameter

func (s *InListContext) PreparedStatementParameter() IPreparedStatementParameterContext

func (*InListContext) QueryExpressionBody

func (s *InListContext) QueryExpressionBody() IQueryExpressionBodyContext

func (*InListContext) RIGHT_ROUND_BRACKET

func (s *InListContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*InListContext) ToStringTree

func (s *InListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type InPredicateContext

type InPredicateContext struct {
	PredicateContext
}

func NewInPredicateContext

func NewInPredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InPredicateContext

func (*InPredicateContext) Accept

func (s *InPredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InPredicateContext) EnterRule

func (s *InPredicateContext) EnterRule(listener antlr.ParseTreeListener)

func (*InPredicateContext) ExitRule

func (s *InPredicateContext) ExitRule(listener antlr.ParseTreeListener)

func (*InPredicateContext) GetRuleContext

func (s *InPredicateContext) GetRuleContext() antlr.RuleContext

func (*InPredicateContext) IN

func (*InPredicateContext) InList

func (s *InPredicateContext) InList() IInListContext

func (*InPredicateContext) NOT

type IncludeClauseContext

type IncludeClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIncludeClauseContext

func NewEmptyIncludeClauseContext() *IncludeClauseContext

func NewIncludeClauseContext

func NewIncludeClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IncludeClauseContext

func (*IncludeClauseContext) Accept

func (s *IncludeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IncludeClauseContext) EnterRule

func (s *IncludeClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*IncludeClauseContext) ExitRule

func (s *IncludeClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*IncludeClauseContext) GetParser

func (s *IncludeClauseContext) GetParser() antlr.Parser

func (*IncludeClauseContext) GetRuleContext

func (s *IncludeClauseContext) GetRuleContext() antlr.RuleContext

func (*IncludeClauseContext) INCLUDE

func (*IncludeClauseContext) IsIncludeClauseContext

func (*IncludeClauseContext) IsIncludeClauseContext()

func (*IncludeClauseContext) LEFT_ROUND_BRACKET

func (s *IncludeClauseContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*IncludeClauseContext) RIGHT_ROUND_BRACKET

func (s *IncludeClauseContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*IncludeClauseContext) ToStringTree

func (s *IncludeClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*IncludeClauseContext) UidList

type IndexAsSelectDefinitionContext

type IndexAsSelectDefinitionContext struct {
	IndexDefinitionContext
	// contains filtered or unexported fields
}

func NewIndexAsSelectDefinitionContext

func NewIndexAsSelectDefinitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IndexAsSelectDefinitionContext

func (*IndexAsSelectDefinitionContext) AS

func (*IndexAsSelectDefinitionContext) Accept

func (s *IndexAsSelectDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexAsSelectDefinitionContext) EnterRule

func (*IndexAsSelectDefinitionContext) ExitRule

func (*IndexAsSelectDefinitionContext) GetIndexName

func (s *IndexAsSelectDefinitionContext) GetIndexName() IUidContext

func (*IndexAsSelectDefinitionContext) GetRuleContext

func (s *IndexAsSelectDefinitionContext) GetRuleContext() antlr.RuleContext

func (*IndexAsSelectDefinitionContext) INDEX

func (*IndexAsSelectDefinitionContext) IndexAttributes

func (*IndexAsSelectDefinitionContext) QueryTerm

func (*IndexAsSelectDefinitionContext) SetIndexName

func (s *IndexAsSelectDefinitionContext) SetIndexName(v IUidContext)

func (*IndexAsSelectDefinitionContext) UNIQUE

func (*IndexAsSelectDefinitionContext) Uid

type IndexAttributeContext

type IndexAttributeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexAttributeContext

func NewEmptyIndexAttributeContext() *IndexAttributeContext

func NewIndexAttributeContext

func NewIndexAttributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexAttributeContext

func (*IndexAttributeContext) Accept

func (s *IndexAttributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexAttributeContext) EnterRule

func (s *IndexAttributeContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexAttributeContext) ExitRule

func (s *IndexAttributeContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexAttributeContext) GetParser

func (s *IndexAttributeContext) GetParser() antlr.Parser

func (*IndexAttributeContext) GetRuleContext

func (s *IndexAttributeContext) GetRuleContext() antlr.RuleContext

func (*IndexAttributeContext) IsIndexAttributeContext

func (*IndexAttributeContext) IsIndexAttributeContext()

func (*IndexAttributeContext) LEGACY_EXTREMUM_EVER

func (s *IndexAttributeContext) LEGACY_EXTREMUM_EVER() antlr.TerminalNode

func (*IndexAttributeContext) ToStringTree

func (s *IndexAttributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IndexAttributesContext

type IndexAttributesContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexAttributesContext

func NewEmptyIndexAttributesContext() *IndexAttributesContext

func NewIndexAttributesContext

func NewIndexAttributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexAttributesContext

func (*IndexAttributesContext) ATTRIBUTES

func (s *IndexAttributesContext) ATTRIBUTES() antlr.TerminalNode

func (*IndexAttributesContext) Accept

func (s *IndexAttributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexAttributesContext) AllCOMMA

func (s *IndexAttributesContext) AllCOMMA() []antlr.TerminalNode

func (*IndexAttributesContext) AllIndexAttribute

func (s *IndexAttributesContext) AllIndexAttribute() []IIndexAttributeContext

func (*IndexAttributesContext) COMMA

func (*IndexAttributesContext) EnterRule

func (s *IndexAttributesContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexAttributesContext) ExitRule

func (s *IndexAttributesContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexAttributesContext) GetParser

func (s *IndexAttributesContext) GetParser() antlr.Parser

func (*IndexAttributesContext) GetRuleContext

func (s *IndexAttributesContext) GetRuleContext() antlr.RuleContext

func (*IndexAttributesContext) IndexAttribute

func (s *IndexAttributesContext) IndexAttribute(i int) IIndexAttributeContext

func (*IndexAttributesContext) IsIndexAttributesContext

func (*IndexAttributesContext) IsIndexAttributesContext()

func (*IndexAttributesContext) ToStringTree

func (s *IndexAttributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*IndexAttributesContext) WITH

type IndexColumnListContext

type IndexColumnListContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexColumnListContext

func NewEmptyIndexColumnListContext() *IndexColumnListContext

func NewIndexColumnListContext

func NewIndexColumnListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnListContext

func (*IndexColumnListContext) Accept

func (s *IndexColumnListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexColumnListContext) AllCOMMA

func (s *IndexColumnListContext) AllCOMMA() []antlr.TerminalNode

func (*IndexColumnListContext) AllIndexColumnSpec

func (s *IndexColumnListContext) AllIndexColumnSpec() []IIndexColumnSpecContext

func (*IndexColumnListContext) COMMA

func (*IndexColumnListContext) EnterRule

func (s *IndexColumnListContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexColumnListContext) ExitRule

func (s *IndexColumnListContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexColumnListContext) GetParser

func (s *IndexColumnListContext) GetParser() antlr.Parser

func (*IndexColumnListContext) GetRuleContext

func (s *IndexColumnListContext) GetRuleContext() antlr.RuleContext

func (*IndexColumnListContext) IndexColumnSpec

func (s *IndexColumnListContext) IndexColumnSpec(i int) IIndexColumnSpecContext

func (*IndexColumnListContext) IsIndexColumnListContext

func (*IndexColumnListContext) IsIndexColumnListContext()

func (*IndexColumnListContext) LEFT_ROUND_BRACKET

func (s *IndexColumnListContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexColumnListContext) RIGHT_ROUND_BRACKET

func (s *IndexColumnListContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexColumnListContext) ToStringTree

func (s *IndexColumnListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IndexColumnNameContext

type IndexColumnNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexColumnNameContext

func NewEmptyIndexColumnNameContext() *IndexColumnNameContext

func NewIndexColumnNameContext

func NewIndexColumnNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnNameContext

func (*IndexColumnNameContext) ASC

func (*IndexColumnNameContext) Accept

func (s *IndexColumnNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexColumnNameContext) DESC

func (*IndexColumnNameContext) DecimalLiteral

func (s *IndexColumnNameContext) DecimalLiteral() IDecimalLiteralContext

func (*IndexColumnNameContext) EnterRule

func (s *IndexColumnNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexColumnNameContext) ExitRule

func (s *IndexColumnNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexColumnNameContext) Expression

func (*IndexColumnNameContext) GetParser

func (s *IndexColumnNameContext) GetParser() antlr.Parser

func (*IndexColumnNameContext) GetRuleContext

func (s *IndexColumnNameContext) GetRuleContext() antlr.RuleContext

func (*IndexColumnNameContext) GetSortType

func (s *IndexColumnNameContext) GetSortType() antlr.Token

func (*IndexColumnNameContext) IsIndexColumnNameContext

func (*IndexColumnNameContext) IsIndexColumnNameContext()

func (*IndexColumnNameContext) LEFT_ROUND_BRACKET

func (s *IndexColumnNameContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexColumnNameContext) RIGHT_ROUND_BRACKET

func (s *IndexColumnNameContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexColumnNameContext) STRING_LITERAL

func (s *IndexColumnNameContext) STRING_LITERAL() antlr.TerminalNode

func (*IndexColumnNameContext) SetSortType

func (s *IndexColumnNameContext) SetSortType(v antlr.Token)

func (*IndexColumnNameContext) ToStringTree

func (s *IndexColumnNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*IndexColumnNameContext) Uid

type IndexColumnNamesContext

type IndexColumnNamesContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexColumnNamesContext

func NewEmptyIndexColumnNamesContext() *IndexColumnNamesContext

func NewIndexColumnNamesContext

func NewIndexColumnNamesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnNamesContext

func (*IndexColumnNamesContext) Accept

func (s *IndexColumnNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexColumnNamesContext) AllCOMMA

func (s *IndexColumnNamesContext) AllCOMMA() []antlr.TerminalNode

func (*IndexColumnNamesContext) AllIndexColumnName

func (s *IndexColumnNamesContext) AllIndexColumnName() []IIndexColumnNameContext

func (*IndexColumnNamesContext) COMMA

func (*IndexColumnNamesContext) EnterRule

func (s *IndexColumnNamesContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexColumnNamesContext) ExitRule

func (s *IndexColumnNamesContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexColumnNamesContext) GetParser

func (s *IndexColumnNamesContext) GetParser() antlr.Parser

func (*IndexColumnNamesContext) GetRuleContext

func (s *IndexColumnNamesContext) GetRuleContext() antlr.RuleContext

func (*IndexColumnNamesContext) IndexColumnName

func (s *IndexColumnNamesContext) IndexColumnName(i int) IIndexColumnNameContext

func (*IndexColumnNamesContext) IsIndexColumnNamesContext

func (*IndexColumnNamesContext) IsIndexColumnNamesContext()

func (*IndexColumnNamesContext) LEFT_ROUND_BRACKET

func (s *IndexColumnNamesContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexColumnNamesContext) RIGHT_ROUND_BRACKET

func (s *IndexColumnNamesContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexColumnNamesContext) ToStringTree

func (s *IndexColumnNamesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IndexColumnSpecContext

type IndexColumnSpecContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexColumnSpecContext

func NewEmptyIndexColumnSpecContext() *IndexColumnSpecContext

func NewIndexColumnSpecContext

func NewIndexColumnSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexColumnSpecContext

func (*IndexColumnSpecContext) Accept

func (s *IndexColumnSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexColumnSpecContext) EnterRule

func (s *IndexColumnSpecContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexColumnSpecContext) ExitRule

func (s *IndexColumnSpecContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexColumnSpecContext) GetColumnName

func (s *IndexColumnSpecContext) GetColumnName() IUidContext

func (*IndexColumnSpecContext) GetParser

func (s *IndexColumnSpecContext) GetParser() antlr.Parser

func (*IndexColumnSpecContext) GetRuleContext

func (s *IndexColumnSpecContext) GetRuleContext() antlr.RuleContext

func (*IndexColumnSpecContext) IsIndexColumnSpecContext

func (*IndexColumnSpecContext) IsIndexColumnSpecContext()

func (*IndexColumnSpecContext) OrderClause

func (*IndexColumnSpecContext) SetColumnName

func (s *IndexColumnSpecContext) SetColumnName(v IUidContext)

func (*IndexColumnSpecContext) ToStringTree

func (s *IndexColumnSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*IndexColumnSpecContext) Uid

type IndexDefinitionContext

type IndexDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexDefinitionContext

func NewEmptyIndexDefinitionContext() *IndexDefinitionContext

func NewIndexDefinitionContext

func NewIndexDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexDefinitionContext

func (*IndexDefinitionContext) CopyAll

func (*IndexDefinitionContext) GetParser

func (s *IndexDefinitionContext) GetParser() antlr.Parser

func (*IndexDefinitionContext) GetRuleContext

func (s *IndexDefinitionContext) GetRuleContext() antlr.RuleContext

func (*IndexDefinitionContext) IsIndexDefinitionContext

func (*IndexDefinitionContext) IsIndexDefinitionContext()

func (*IndexDefinitionContext) ToStringTree

func (s *IndexDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IndexHintContext

type IndexHintContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexHintContext

func NewEmptyIndexHintContext() *IndexHintContext

func NewIndexHintContext

func NewIndexHintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexHintContext

func (*IndexHintContext) Accept

func (s *IndexHintContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexHintContext) EnterRule

func (s *IndexHintContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexHintContext) ExitRule

func (s *IndexHintContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexHintContext) FOR

func (*IndexHintContext) FORCE

func (s *IndexHintContext) FORCE() antlr.TerminalNode

func (*IndexHintContext) GetIndexHintAction

func (s *IndexHintContext) GetIndexHintAction() antlr.Token

func (*IndexHintContext) GetKeyFormat

func (s *IndexHintContext) GetKeyFormat() antlr.Token

func (*IndexHintContext) GetParser

func (s *IndexHintContext) GetParser() antlr.Parser

func (*IndexHintContext) GetRuleContext

func (s *IndexHintContext) GetRuleContext() antlr.RuleContext

func (*IndexHintContext) IGNORE

func (s *IndexHintContext) IGNORE() antlr.TerminalNode

func (*IndexHintContext) INDEX

func (s *IndexHintContext) INDEX() antlr.TerminalNode

func (*IndexHintContext) IndexHintType

func (s *IndexHintContext) IndexHintType() IIndexHintTypeContext

func (*IndexHintContext) IsIndexHintContext

func (*IndexHintContext) IsIndexHintContext()

func (*IndexHintContext) KEY

func (*IndexHintContext) LEFT_ROUND_BRACKET

func (s *IndexHintContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexHintContext) RIGHT_ROUND_BRACKET

func (s *IndexHintContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexHintContext) SetIndexHintAction

func (s *IndexHintContext) SetIndexHintAction(v antlr.Token)

func (*IndexHintContext) SetKeyFormat

func (s *IndexHintContext) SetKeyFormat(v antlr.Token)

func (*IndexHintContext) ToStringTree

func (s *IndexHintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*IndexHintContext) USE

func (*IndexHintContext) UidList

func (s *IndexHintContext) UidList() IUidListContext

type IndexHintTypeContext

type IndexHintTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexHintTypeContext

func NewEmptyIndexHintTypeContext() *IndexHintTypeContext

func NewIndexHintTypeContext

func NewIndexHintTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexHintTypeContext

func (*IndexHintTypeContext) Accept

func (s *IndexHintTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexHintTypeContext) BY

func (*IndexHintTypeContext) EnterRule

func (s *IndexHintTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexHintTypeContext) ExitRule

func (s *IndexHintTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexHintTypeContext) GROUP

func (*IndexHintTypeContext) GetParser

func (s *IndexHintTypeContext) GetParser() antlr.Parser

func (*IndexHintTypeContext) GetRuleContext

func (s *IndexHintTypeContext) GetRuleContext() antlr.RuleContext

func (*IndexHintTypeContext) IsIndexHintTypeContext

func (*IndexHintTypeContext) IsIndexHintTypeContext()

func (*IndexHintTypeContext) JOIN

func (*IndexHintTypeContext) ORDER

func (*IndexHintTypeContext) ToStringTree

func (s *IndexHintTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IndexOnSourceDefinitionContext

type IndexOnSourceDefinitionContext struct {
	IndexDefinitionContext
	// contains filtered or unexported fields
}

func NewIndexOnSourceDefinitionContext

func NewIndexOnSourceDefinitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IndexOnSourceDefinitionContext

func (*IndexOnSourceDefinitionContext) Accept

func (s *IndexOnSourceDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexOnSourceDefinitionContext) EnterRule

func (*IndexOnSourceDefinitionContext) ExitRule

func (*IndexOnSourceDefinitionContext) FullId

func (*IndexOnSourceDefinitionContext) GetIndexName

func (s *IndexOnSourceDefinitionContext) GetIndexName() IUidContext

func (*IndexOnSourceDefinitionContext) GetRuleContext

func (s *IndexOnSourceDefinitionContext) GetRuleContext() antlr.RuleContext

func (*IndexOnSourceDefinitionContext) GetSource

func (*IndexOnSourceDefinitionContext) INDEX

func (*IndexOnSourceDefinitionContext) IncludeClause

func (*IndexOnSourceDefinitionContext) IndexColumnList

func (*IndexOnSourceDefinitionContext) IndexOptions

func (*IndexOnSourceDefinitionContext) ON

func (*IndexOnSourceDefinitionContext) SetIndexName

func (s *IndexOnSourceDefinitionContext) SetIndexName(v IUidContext)

func (*IndexOnSourceDefinitionContext) SetSource

func (*IndexOnSourceDefinitionContext) UNIQUE

func (*IndexOnSourceDefinitionContext) Uid

type IndexOptionContext

type IndexOptionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexOptionContext

func NewEmptyIndexOptionContext() *IndexOptionContext

func NewIndexOptionContext

func NewIndexOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexOptionContext

func (*IndexOptionContext) Accept

func (s *IndexOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexOptionContext) EnterRule

func (s *IndexOptionContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexOptionContext) ExitRule

func (s *IndexOptionContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexOptionContext) GetParser

func (s *IndexOptionContext) GetParser() antlr.Parser

func (*IndexOptionContext) GetRuleContext

func (s *IndexOptionContext) GetRuleContext() antlr.RuleContext

func (*IndexOptionContext) IsIndexOptionContext

func (*IndexOptionContext) IsIndexOptionContext()

func (*IndexOptionContext) LEGACY_EXTREMUM_EVER

func (s *IndexOptionContext) LEGACY_EXTREMUM_EVER() antlr.TerminalNode

func (*IndexOptionContext) ToStringTree

func (s *IndexOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IndexOptionsContext

type IndexOptionsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexOptionsContext

func NewEmptyIndexOptionsContext() *IndexOptionsContext

func NewIndexOptionsContext

func NewIndexOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexOptionsContext

func (*IndexOptionsContext) Accept

func (s *IndexOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexOptionsContext) AllCOMMA

func (s *IndexOptionsContext) AllCOMMA() []antlr.TerminalNode

func (*IndexOptionsContext) AllIndexOption

func (s *IndexOptionsContext) AllIndexOption() []IIndexOptionContext

func (*IndexOptionsContext) COMMA

func (*IndexOptionsContext) EnterRule

func (s *IndexOptionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexOptionsContext) ExitRule

func (s *IndexOptionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexOptionsContext) GetParser

func (s *IndexOptionsContext) GetParser() antlr.Parser

func (*IndexOptionsContext) GetRuleContext

func (s *IndexOptionsContext) GetRuleContext() antlr.RuleContext

func (*IndexOptionsContext) IndexOption

func (s *IndexOptionsContext) IndexOption(i int) IIndexOptionContext

func (*IndexOptionsContext) IsIndexOptionsContext

func (*IndexOptionsContext) IsIndexOptionsContext()

func (*IndexOptionsContext) LEFT_ROUND_BRACKET

func (s *IndexOptionsContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexOptionsContext) OPTIONS

func (s *IndexOptionsContext) OPTIONS() antlr.TerminalNode

func (*IndexOptionsContext) RIGHT_ROUND_BRACKET

func (s *IndexOptionsContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexOptionsContext) ToStringTree

func (s *IndexOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IndexPartitionClauseContext

type IndexPartitionClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexPartitionClauseContext

func NewEmptyIndexPartitionClauseContext() *IndexPartitionClauseContext

func NewIndexPartitionClauseContext

func NewIndexPartitionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexPartitionClauseContext

func (*IndexPartitionClauseContext) Accept

func (s *IndexPartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexPartitionClauseContext) AllCOMMA

func (*IndexPartitionClauseContext) AllIndexColumnSpec

func (s *IndexPartitionClauseContext) AllIndexColumnSpec() []IIndexColumnSpecContext

func (*IndexPartitionClauseContext) BY

func (*IndexPartitionClauseContext) COMMA

func (*IndexPartitionClauseContext) EnterRule

func (s *IndexPartitionClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexPartitionClauseContext) ExitRule

func (s *IndexPartitionClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexPartitionClauseContext) GetParser

func (s *IndexPartitionClauseContext) GetParser() antlr.Parser

func (*IndexPartitionClauseContext) GetRuleContext

func (s *IndexPartitionClauseContext) GetRuleContext() antlr.RuleContext

func (*IndexPartitionClauseContext) IndexColumnSpec

func (*IndexPartitionClauseContext) IsIndexPartitionClauseContext

func (*IndexPartitionClauseContext) IsIndexPartitionClauseContext()

func (*IndexPartitionClauseContext) LEFT_ROUND_BRACKET

func (s *IndexPartitionClauseContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexPartitionClauseContext) PARTITION

func (*IndexPartitionClauseContext) RIGHT_ROUND_BRACKET

func (s *IndexPartitionClauseContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*IndexPartitionClauseContext) ToStringTree

func (s *IndexPartitionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IndexTypeContext

type IndexTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndexTypeContext

func NewEmptyIndexTypeContext() *IndexTypeContext

func NewIndexTypeContext

func NewIndexTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexTypeContext

func (*IndexTypeContext) Accept

func (s *IndexTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IndexTypeContext) EnterRule

func (s *IndexTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*IndexTypeContext) ExitRule

func (s *IndexTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*IndexTypeContext) GetParser

func (s *IndexTypeContext) GetParser() antlr.Parser

func (*IndexTypeContext) GetRuleContext

func (s *IndexTypeContext) GetRuleContext() antlr.RuleContext

func (*IndexTypeContext) IsIndexTypeContext

func (*IndexTypeContext) IsIndexTypeContext()

func (*IndexTypeContext) ToStringTree

func (s *IndexTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*IndexTypeContext) UNIQUE

func (s *IndexTypeContext) UNIQUE() antlr.TerminalNode

func (*IndexTypeContext) VECTOR

func (s *IndexTypeContext) VECTOR() antlr.TerminalNode

type InlineTableDefinitionContext

type InlineTableDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyInlineTableDefinitionContext

func NewEmptyInlineTableDefinitionContext() *InlineTableDefinitionContext

func NewInlineTableDefinitionContext

func NewInlineTableDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InlineTableDefinitionContext

func (*InlineTableDefinitionContext) AS

func (*InlineTableDefinitionContext) Accept

func (s *InlineTableDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InlineTableDefinitionContext) EnterRule

func (s *InlineTableDefinitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*InlineTableDefinitionContext) ExitRule

func (*InlineTableDefinitionContext) GetParser

func (s *InlineTableDefinitionContext) GetParser() antlr.Parser

func (*InlineTableDefinitionContext) GetRuleContext

func (s *InlineTableDefinitionContext) GetRuleContext() antlr.RuleContext

func (*InlineTableDefinitionContext) IsInlineTableDefinitionContext

func (*InlineTableDefinitionContext) IsInlineTableDefinitionContext()

func (*InlineTableDefinitionContext) TableName

func (*InlineTableDefinitionContext) ToStringTree

func (s *InlineTableDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*InlineTableDefinitionContext) UidListWithNestingsInParens

func (s *InlineTableDefinitionContext) UidListWithNestingsInParens() IUidListWithNestingsInParensContext

type InlineTableItemContext

type InlineTableItemContext struct {
	TableSourceItemContext
}

func NewInlineTableItemContext

func NewInlineTableItemContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InlineTableItemContext

func (*InlineTableItemContext) Accept

func (s *InlineTableItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InlineTableItemContext) AllCOMMA

func (s *InlineTableItemContext) AllCOMMA() []antlr.TerminalNode

func (*InlineTableItemContext) AllRecordConstructorForInlineTable

func (s *InlineTableItemContext) AllRecordConstructorForInlineTable() []IRecordConstructorForInlineTableContext

func (*InlineTableItemContext) COMMA

func (*InlineTableItemContext) EnterRule

func (s *InlineTableItemContext) EnterRule(listener antlr.ParseTreeListener)

func (*InlineTableItemContext) ExitRule

func (s *InlineTableItemContext) ExitRule(listener antlr.ParseTreeListener)

func (*InlineTableItemContext) GetRuleContext

func (s *InlineTableItemContext) GetRuleContext() antlr.RuleContext

func (*InlineTableItemContext) InlineTableDefinition

func (s *InlineTableItemContext) InlineTableDefinition() IInlineTableDefinitionContext

func (*InlineTableItemContext) RecordConstructorForInlineTable

func (s *InlineTableItemContext) RecordConstructorForInlineTable(i int) IRecordConstructorForInlineTableContext

func (*InlineTableItemContext) VALUES

type InnerJoinContext

type InnerJoinContext struct {
	JoinPartContext
}

func NewInnerJoinContext

func NewInnerJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *InnerJoinContext

func (*InnerJoinContext) Accept

func (s *InnerJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InnerJoinContext) CROSS

func (s *InnerJoinContext) CROSS() antlr.TerminalNode

func (*InnerJoinContext) EnterRule

func (s *InnerJoinContext) EnterRule(listener antlr.ParseTreeListener)

func (*InnerJoinContext) ExitRule

func (s *InnerJoinContext) ExitRule(listener antlr.ParseTreeListener)

func (*InnerJoinContext) Expression

func (s *InnerJoinContext) Expression() IExpressionContext

func (*InnerJoinContext) GetRuleContext

func (s *InnerJoinContext) GetRuleContext() antlr.RuleContext

func (*InnerJoinContext) INNER

func (s *InnerJoinContext) INNER() antlr.TerminalNode

func (*InnerJoinContext) JOIN

func (*InnerJoinContext) LEFT_ROUND_BRACKET

func (s *InnerJoinContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*InnerJoinContext) ON

func (*InnerJoinContext) RIGHT_ROUND_BRACKET

func (s *InnerJoinContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*InnerJoinContext) TableSourceItem

func (s *InnerJoinContext) TableSourceItem() ITableSourceItemContext

func (*InnerJoinContext) USING

func (s *InnerJoinContext) USING() antlr.TerminalNode

func (*InnerJoinContext) UidList

func (s *InnerJoinContext) UidList() IUidListContext

type InsertStatementContext

type InsertStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyInsertStatementContext

func NewEmptyInsertStatementContext() *InsertStatementContext

func NewInsertStatementContext

func NewInsertStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertStatementContext

func (*InsertStatementContext) Accept

func (s *InsertStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InsertStatementContext) EnterRule

func (s *InsertStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*InsertStatementContext) ExitRule

func (s *InsertStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*InsertStatementContext) GetColumns

func (*InsertStatementContext) GetParser

func (s *InsertStatementContext) GetParser() antlr.Parser

func (*InsertStatementContext) GetRuleContext

func (s *InsertStatementContext) GetRuleContext() antlr.RuleContext

func (*InsertStatementContext) INSERT

func (*InsertStatementContext) INTO

func (*InsertStatementContext) InsertStatementValue

func (s *InsertStatementContext) InsertStatementValue() IInsertStatementValueContext

func (*InsertStatementContext) IsInsertStatementContext

func (*InsertStatementContext) IsInsertStatementContext()

func (*InsertStatementContext) SetColumns

func (*InsertStatementContext) StatementOptions

func (s *InsertStatementContext) StatementOptions() IStatementOptionsContext

func (*InsertStatementContext) TableName

func (*InsertStatementContext) ToStringTree

func (s *InsertStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*InsertStatementContext) UidListWithNestingsInParens

func (s *InsertStatementContext) UidListWithNestingsInParens() IUidListWithNestingsInParensContext

type InsertStatementValueContext

type InsertStatementValueContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyInsertStatementValueContext

func NewEmptyInsertStatementValueContext() *InsertStatementValueContext

func NewInsertStatementValueContext

func NewInsertStatementValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertStatementValueContext

func (*InsertStatementValueContext) CopyAll

func (*InsertStatementValueContext) GetParser

func (s *InsertStatementValueContext) GetParser() antlr.Parser

func (*InsertStatementValueContext) GetRuleContext

func (s *InsertStatementValueContext) GetRuleContext() antlr.RuleContext

func (*InsertStatementValueContext) IsInsertStatementValueContext

func (*InsertStatementValueContext) IsInsertStatementValueContext()

func (*InsertStatementValueContext) ToStringTree

func (s *InsertStatementValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type InsertStatementValueSelectContext

type InsertStatementValueSelectContext struct {
	InsertStatementValueContext
}

func (*InsertStatementValueSelectContext) Accept

func (s *InsertStatementValueSelectContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InsertStatementValueSelectContext) EnterRule

func (*InsertStatementValueSelectContext) ExitRule

func (*InsertStatementValueSelectContext) GetRuleContext

func (*InsertStatementValueSelectContext) QueryExpressionBody

type InsertStatementValueValuesContext

type InsertStatementValueValuesContext struct {
	InsertStatementValueContext
	// contains filtered or unexported fields
}

func (*InsertStatementValueValuesContext) Accept

func (s *InsertStatementValueValuesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InsertStatementValueValuesContext) AllCOMMA

func (*InsertStatementValueValuesContext) AllRecordConstructorForInsert

func (s *InsertStatementValueValuesContext) AllRecordConstructorForInsert() []IRecordConstructorForInsertContext

func (*InsertStatementValueValuesContext) COMMA

func (*InsertStatementValueValuesContext) EnterRule

func (*InsertStatementValueValuesContext) ExitRule

func (*InsertStatementValueValuesContext) GetInsertFormat

func (s *InsertStatementValueValuesContext) GetInsertFormat() antlr.Token

func (*InsertStatementValueValuesContext) GetRuleContext

func (*InsertStatementValueValuesContext) RecordConstructorForInsert

func (*InsertStatementValueValuesContext) SetInsertFormat

func (s *InsertStatementValueValuesContext) SetInsertFormat(v antlr.Token)

func (*InsertStatementValueValuesContext) VALUE

func (*InsertStatementValueValuesContext) VALUES

type IntervalTypeBaseContext

type IntervalTypeBaseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIntervalTypeBaseContext

func NewEmptyIntervalTypeBaseContext() *IntervalTypeBaseContext

func NewIntervalTypeBaseContext

func NewIntervalTypeBaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntervalTypeBaseContext

func (*IntervalTypeBaseContext) Accept

func (s *IntervalTypeBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IntervalTypeBaseContext) DAY

func (*IntervalTypeBaseContext) EnterRule

func (s *IntervalTypeBaseContext) EnterRule(listener antlr.ParseTreeListener)

func (*IntervalTypeBaseContext) ExitRule

func (s *IntervalTypeBaseContext) ExitRule(listener antlr.ParseTreeListener)

func (*IntervalTypeBaseContext) GetParser

func (s *IntervalTypeBaseContext) GetParser() antlr.Parser

func (*IntervalTypeBaseContext) GetRuleContext

func (s *IntervalTypeBaseContext) GetRuleContext() antlr.RuleContext

func (*IntervalTypeBaseContext) HOUR

func (*IntervalTypeBaseContext) IsIntervalTypeBaseContext

func (*IntervalTypeBaseContext) IsIntervalTypeBaseContext()

func (*IntervalTypeBaseContext) MICROSECOND

func (s *IntervalTypeBaseContext) MICROSECOND() antlr.TerminalNode

func (*IntervalTypeBaseContext) MINUTE

func (*IntervalTypeBaseContext) MONTH

func (*IntervalTypeBaseContext) QUARTER

func (*IntervalTypeBaseContext) SECOND

func (*IntervalTypeBaseContext) ToStringTree

func (s *IntervalTypeBaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*IntervalTypeBaseContext) WEEK

type IntervalTypeContext

type IntervalTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIntervalTypeContext

func NewEmptyIntervalTypeContext() *IntervalTypeContext

func NewIntervalTypeContext

func NewIntervalTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntervalTypeContext

func (*IntervalTypeContext) Accept

func (s *IntervalTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IntervalTypeContext) DAY_HOUR

func (s *IntervalTypeContext) DAY_HOUR() antlr.TerminalNode

func (*IntervalTypeContext) DAY_MICROSECOND

func (s *IntervalTypeContext) DAY_MICROSECOND() antlr.TerminalNode

func (*IntervalTypeContext) DAY_MINUTE

func (s *IntervalTypeContext) DAY_MINUTE() antlr.TerminalNode

func (*IntervalTypeContext) DAY_SECOND

func (s *IntervalTypeContext) DAY_SECOND() antlr.TerminalNode

func (*IntervalTypeContext) EnterRule

func (s *IntervalTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*IntervalTypeContext) ExitRule

func (s *IntervalTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*IntervalTypeContext) GetParser

func (s *IntervalTypeContext) GetParser() antlr.Parser

func (*IntervalTypeContext) GetRuleContext

func (s *IntervalTypeContext) GetRuleContext() antlr.RuleContext

func (*IntervalTypeContext) HOUR_MICROSECOND

func (s *IntervalTypeContext) HOUR_MICROSECOND() antlr.TerminalNode

func (*IntervalTypeContext) HOUR_MINUTE

func (s *IntervalTypeContext) HOUR_MINUTE() antlr.TerminalNode

func (*IntervalTypeContext) HOUR_SECOND

func (s *IntervalTypeContext) HOUR_SECOND() antlr.TerminalNode

func (*IntervalTypeContext) IntervalTypeBase

func (s *IntervalTypeContext) IntervalTypeBase() IIntervalTypeBaseContext

func (*IntervalTypeContext) IsIntervalTypeContext

func (*IntervalTypeContext) IsIntervalTypeContext()

func (*IntervalTypeContext) MINUTE_MICROSECOND

func (s *IntervalTypeContext) MINUTE_MICROSECOND() antlr.TerminalNode

func (*IntervalTypeContext) MINUTE_SECOND

func (s *IntervalTypeContext) MINUTE_SECOND() antlr.TerminalNode

func (*IntervalTypeContext) SECOND_MICROSECOND

func (s *IntervalTypeContext) SECOND_MICROSECOND() antlr.TerminalNode

func (*IntervalTypeContext) ToStringTree

func (s *IntervalTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*IntervalTypeContext) YEAR

func (*IntervalTypeContext) YEAR_MONTH

func (s *IntervalTypeContext) YEAR_MONTH() antlr.TerminalNode

type IsExpressionContext

type IsExpressionContext struct {
	PredicateContext
	// contains filtered or unexported fields
}

func NewIsExpressionContext

func NewIsExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IsExpressionContext

func (*IsExpressionContext) Accept

func (s *IsExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IsExpressionContext) EnterRule

func (s *IsExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*IsExpressionContext) ExitRule

func (s *IsExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*IsExpressionContext) FALSE

func (*IsExpressionContext) GetRuleContext

func (s *IsExpressionContext) GetRuleContext() antlr.RuleContext

func (*IsExpressionContext) GetTestValue

func (s *IsExpressionContext) GetTestValue() antlr.Token

func (*IsExpressionContext) IS

func (*IsExpressionContext) NOT

func (*IsExpressionContext) NULL_LITERAL

func (s *IsExpressionContext) NULL_LITERAL() antlr.TerminalNode

func (*IsExpressionContext) SetTestValue

func (s *IsExpressionContext) SetTestValue(v antlr.Token)

func (*IsExpressionContext) TRUE

type JoinPartContext

type JoinPartContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyJoinPartContext

func NewEmptyJoinPartContext() *JoinPartContext

func NewJoinPartContext

func NewJoinPartContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JoinPartContext

func (*JoinPartContext) CopyAll

func (s *JoinPartContext) CopyAll(ctx *JoinPartContext)

func (*JoinPartContext) GetParser

func (s *JoinPartContext) GetParser() antlr.Parser

func (*JoinPartContext) GetRuleContext

func (s *JoinPartContext) GetRuleContext() antlr.RuleContext

func (*JoinPartContext) IsJoinPartContext

func (*JoinPartContext) IsJoinPartContext()

func (*JoinPartContext) ToStringTree

func (s *JoinPartContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type JsonOperatorContext

type JsonOperatorContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyJsonOperatorContext

func NewEmptyJsonOperatorContext() *JsonOperatorContext

func NewJsonOperatorContext

func NewJsonOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *JsonOperatorContext

func (*JsonOperatorContext) Accept

func (s *JsonOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*JsonOperatorContext) AllGREATER_SYMBOL

func (s *JsonOperatorContext) AllGREATER_SYMBOL() []antlr.TerminalNode

func (*JsonOperatorContext) EnterRule

func (s *JsonOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*JsonOperatorContext) ExitRule

func (s *JsonOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*JsonOperatorContext) GREATER_SYMBOL

func (s *JsonOperatorContext) GREATER_SYMBOL(i int) antlr.TerminalNode

func (*JsonOperatorContext) GetParser

func (s *JsonOperatorContext) GetParser() antlr.Parser

func (*JsonOperatorContext) GetRuleContext

func (s *JsonOperatorContext) GetRuleContext() antlr.RuleContext

func (*JsonOperatorContext) IsJsonOperatorContext

func (*JsonOperatorContext) IsJsonOperatorContext()

func (*JsonOperatorContext) MINUS

func (*JsonOperatorContext) ToStringTree

func (s *JsonOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type KeywordsCanBeIdContext

type KeywordsCanBeIdContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyKeywordsCanBeIdContext

func NewEmptyKeywordsCanBeIdContext() *KeywordsCanBeIdContext

func NewKeywordsCanBeIdContext

func NewKeywordsCanBeIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordsCanBeIdContext

func (*KeywordsCanBeIdContext) ACCOUNT

func (*KeywordsCanBeIdContext) ACTION

func (*KeywordsCanBeIdContext) ADMIN

func (*KeywordsCanBeIdContext) AFTER

func (*KeywordsCanBeIdContext) AGGREGATE

func (s *KeywordsCanBeIdContext) AGGREGATE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) ALGORITHM

func (s *KeywordsCanBeIdContext) ALGORITHM() antlr.TerminalNode

func (*KeywordsCanBeIdContext) ANY

func (*KeywordsCanBeIdContext) ARRAY_AGG

func (s *KeywordsCanBeIdContext) ARRAY_AGG() antlr.TerminalNode

func (*KeywordsCanBeIdContext) AT

func (*KeywordsCanBeIdContext) AUDIT_ADMIN

func (s *KeywordsCanBeIdContext) AUDIT_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) AUTHORS

func (*KeywordsCanBeIdContext) AUTOCOMMIT

func (s *KeywordsCanBeIdContext) AUTOCOMMIT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) AUTOEXTEND_SIZE

func (s *KeywordsCanBeIdContext) AUTOEXTEND_SIZE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) AUTO_INCREMENT

func (s *KeywordsCanBeIdContext) AUTO_INCREMENT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) AVG

func (*KeywordsCanBeIdContext) AVG_ROW_LENGTH

func (s *KeywordsCanBeIdContext) AVG_ROW_LENGTH() antlr.TerminalNode

func (*KeywordsCanBeIdContext) Accept

func (s *KeywordsCanBeIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*KeywordsCanBeIdContext) BACKUP_ADMIN

func (s *KeywordsCanBeIdContext) BACKUP_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) BEGIN

func (*KeywordsCanBeIdContext) BINLOG

func (*KeywordsCanBeIdContext) BINLOG_ADMIN

func (s *KeywordsCanBeIdContext) BINLOG_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) BINLOG_ENCRYPTION_ADMIN

func (s *KeywordsCanBeIdContext) BINLOG_ENCRYPTION_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) BIT

func (*KeywordsCanBeIdContext) BIT_AND

func (*KeywordsCanBeIdContext) BIT_OR

func (*KeywordsCanBeIdContext) BIT_XOR

func (*KeywordsCanBeIdContext) BLOCK

func (*KeywordsCanBeIdContext) BOOL

func (*KeywordsCanBeIdContext) BTREE

func (*KeywordsCanBeIdContext) CACHE

func (*KeywordsCanBeIdContext) CASCADED

func (*KeywordsCanBeIdContext) CATALOG_NAME

func (s *KeywordsCanBeIdContext) CATALOG_NAME() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CHAIN

func (*KeywordsCanBeIdContext) CHANGED

func (*KeywordsCanBeIdContext) CHANNEL

func (*KeywordsCanBeIdContext) CHECKSUM

func (*KeywordsCanBeIdContext) CIPHER

func (*KeywordsCanBeIdContext) CLASS_ORIGIN

func (s *KeywordsCanBeIdContext) CLASS_ORIGIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CLIENT

func (*KeywordsCanBeIdContext) CLONE_ADMIN

func (s *KeywordsCanBeIdContext) CLONE_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CLOSE

func (*KeywordsCanBeIdContext) CLUSTERING

func (s *KeywordsCanBeIdContext) CLUSTERING() antlr.TerminalNode

func (*KeywordsCanBeIdContext) COALESCE

func (*KeywordsCanBeIdContext) CODE

func (*KeywordsCanBeIdContext) COLUMNS

func (*KeywordsCanBeIdContext) COLUMN_FORMAT

func (s *KeywordsCanBeIdContext) COLUMN_FORMAT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) COLUMN_NAME

func (s *KeywordsCanBeIdContext) COLUMN_NAME() antlr.TerminalNode

func (*KeywordsCanBeIdContext) COMMENT

func (*KeywordsCanBeIdContext) COMMIT

func (*KeywordsCanBeIdContext) COMPACT

func (*KeywordsCanBeIdContext) COMPLETION

func (s *KeywordsCanBeIdContext) COMPLETION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) COMPRESSED

func (s *KeywordsCanBeIdContext) COMPRESSED() antlr.TerminalNode

func (*KeywordsCanBeIdContext) COMPRESSION

func (s *KeywordsCanBeIdContext) COMPRESSION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CONCURRENT

func (s *KeywordsCanBeIdContext) CONCURRENT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CONNECT

func (*KeywordsCanBeIdContext) CONNECTION

func (s *KeywordsCanBeIdContext) CONNECTION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CONNECTION_ADMIN

func (s *KeywordsCanBeIdContext) CONNECTION_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CONNECTIVITY

func (s *KeywordsCanBeIdContext) CONNECTIVITY() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CONSISTENT

func (s *KeywordsCanBeIdContext) CONSISTENT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CONSTRAINT_CATALOG

func (s *KeywordsCanBeIdContext) CONSTRAINT_CATALOG() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CONSTRAINT_NAME

func (s *KeywordsCanBeIdContext) CONSTRAINT_NAME() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CONSTRAINT_SCHEMA

func (s *KeywordsCanBeIdContext) CONSTRAINT_SCHEMA() antlr.TerminalNode

func (*KeywordsCanBeIdContext) CONTAINS

func (*KeywordsCanBeIdContext) CONTEXT

func (*KeywordsCanBeIdContext) CONTRIBUTORS

func (s *KeywordsCanBeIdContext) CONTRIBUTORS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) COPY

func (*KeywordsCanBeIdContext) CPU

func (*KeywordsCanBeIdContext) CURRENT

func (*KeywordsCanBeIdContext) CURSOR_NAME

func (s *KeywordsCanBeIdContext) CURSOR_NAME() antlr.TerminalNode

func (*KeywordsCanBeIdContext) DATA

func (*KeywordsCanBeIdContext) DATABASES

func (s *KeywordsCanBeIdContext) DATABASES() antlr.TerminalNode

func (*KeywordsCanBeIdContext) DATAFILE

func (*KeywordsCanBeIdContext) DEALLOCATE

func (s *KeywordsCanBeIdContext) DEALLOCATE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) DEFAULT_AUTH

func (s *KeywordsCanBeIdContext) DEFAULT_AUTH() antlr.TerminalNode

func (*KeywordsCanBeIdContext) DEFINER

func (*KeywordsCanBeIdContext) DELAY_KEY_WRITE

func (s *KeywordsCanBeIdContext) DELAY_KEY_WRITE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) DES_KEY_FILE

func (s *KeywordsCanBeIdContext) DES_KEY_FILE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) DIRECTORY

func (s *KeywordsCanBeIdContext) DIRECTORY() antlr.TerminalNode

func (*KeywordsCanBeIdContext) DISABLE

func (*KeywordsCanBeIdContext) DISCARD

func (*KeywordsCanBeIdContext) DISK

func (*KeywordsCanBeIdContext) DO

func (*KeywordsCanBeIdContext) DUMPFILE

func (*KeywordsCanBeIdContext) DUPLICATE

func (s *KeywordsCanBeIdContext) DUPLICATE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) DYNAMIC

func (*KeywordsCanBeIdContext) EF_CONSTRUCTION

func (s *KeywordsCanBeIdContext) EF_CONSTRUCTION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) ENABLE

func (*KeywordsCanBeIdContext) ENCRYPTION

func (s *KeywordsCanBeIdContext) ENCRYPTION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) ENCRYPTION_KEY_ADMIN

func (s *KeywordsCanBeIdContext) ENCRYPTION_KEY_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) END

func (*KeywordsCanBeIdContext) ENDS

func (*KeywordsCanBeIdContext) ENGINE

func (*KeywordsCanBeIdContext) ENGINES

func (*KeywordsCanBeIdContext) ENGINE_ATTRIBUTE

func (s *KeywordsCanBeIdContext) ENGINE_ATTRIBUTE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) ERROR

func (*KeywordsCanBeIdContext) ERRORS

func (*KeywordsCanBeIdContext) ESCAPE

func (*KeywordsCanBeIdContext) EUR

func (*KeywordsCanBeIdContext) EVEN

func (*KeywordsCanBeIdContext) EVENT

func (*KeywordsCanBeIdContext) EVENTS

func (*KeywordsCanBeIdContext) EVERY

func (*KeywordsCanBeIdContext) EXCEPT

func (*KeywordsCanBeIdContext) EXCHANGE

func (*KeywordsCanBeIdContext) EXCLUSIVE

func (s *KeywordsCanBeIdContext) EXCLUSIVE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) EXIT

func (*KeywordsCanBeIdContext) EXPIRE

func (*KeywordsCanBeIdContext) EXPORT

func (*KeywordsCanBeIdContext) EXTENDED

func (*KeywordsCanBeIdContext) EXTENT_SIZE

func (s *KeywordsCanBeIdContext) EXTENT_SIZE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) EnterRule

func (s *KeywordsCanBeIdContext) EnterRule(listener antlr.ParseTreeListener)

func (*KeywordsCanBeIdContext) ExitRule

func (s *KeywordsCanBeIdContext) ExitRule(listener antlr.ParseTreeListener)

func (*KeywordsCanBeIdContext) FAST

func (*KeywordsCanBeIdContext) FAULTS

func (*KeywordsCanBeIdContext) FIELDS

func (*KeywordsCanBeIdContext) FILE_BLOCK_SIZE

func (s *KeywordsCanBeIdContext) FILE_BLOCK_SIZE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) FILTER

func (*KeywordsCanBeIdContext) FIREWALL_ADMIN

func (s *KeywordsCanBeIdContext) FIREWALL_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) FIREWALL_USER

func (s *KeywordsCanBeIdContext) FIREWALL_USER() antlr.TerminalNode

func (*KeywordsCanBeIdContext) FIRST

func (*KeywordsCanBeIdContext) FIXED

func (*KeywordsCanBeIdContext) FLUSH

func (*KeywordsCanBeIdContext) FOLLOWS

func (*KeywordsCanBeIdContext) FOUND

func (*KeywordsCanBeIdContext) FUNCTION

func (*KeywordsCanBeIdContext) GENERAL

func (*KeywordsCanBeIdContext) GLOBAL

func (*KeywordsCanBeIdContext) GRANTS

func (*KeywordsCanBeIdContext) GROUP

func (*KeywordsCanBeIdContext) GROUP_CONCAT

func (s *KeywordsCanBeIdContext) GROUP_CONCAT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) GetParser

func (s *KeywordsCanBeIdContext) GetParser() antlr.Parser

func (*KeywordsCanBeIdContext) GetRuleContext

func (s *KeywordsCanBeIdContext) GetRuleContext() antlr.RuleContext

func (*KeywordsCanBeIdContext) HANDLER

func (*KeywordsCanBeIdContext) HASH

func (*KeywordsCanBeIdContext) HELP

func (*KeywordsCanBeIdContext) HOST

func (*KeywordsCanBeIdContext) HOSTS

func (*KeywordsCanBeIdContext) IDENTIFIED

func (s *KeywordsCanBeIdContext) IDENTIFIED() antlr.TerminalNode

func (*KeywordsCanBeIdContext) IGNORED

func (*KeywordsCanBeIdContext) IGNORE_SERVER_IDS

func (s *KeywordsCanBeIdContext) IGNORE_SERVER_IDS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) IMPORT

func (*KeywordsCanBeIdContext) INDEX

func (*KeywordsCanBeIdContext) INDEXES

func (*KeywordsCanBeIdContext) INITIAL_SIZE

func (s *KeywordsCanBeIdContext) INITIAL_SIZE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) INNODB_REDO_LOG_ARCHIVE

func (s *KeywordsCanBeIdContext) INNODB_REDO_LOG_ARCHIVE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) INPLACE

func (*KeywordsCanBeIdContext) INSERT_METHOD

func (s *KeywordsCanBeIdContext) INSERT_METHOD() antlr.TerminalNode

func (*KeywordsCanBeIdContext) INSTALL

func (*KeywordsCanBeIdContext) INSTANCE

func (*KeywordsCanBeIdContext) INSTANT

func (*KeywordsCanBeIdContext) INTERNAL

func (*KeywordsCanBeIdContext) INVOKER

func (*KeywordsCanBeIdContext) IO

func (*KeywordsCanBeIdContext) IO_THREAD

func (s *KeywordsCanBeIdContext) IO_THREAD() antlr.TerminalNode

func (*KeywordsCanBeIdContext) IPC

func (*KeywordsCanBeIdContext) ISO

func (*KeywordsCanBeIdContext) ISOLATION

func (s *KeywordsCanBeIdContext) ISOLATION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) ISSUER

func (*KeywordsCanBeIdContext) IsKeywordsCanBeIdContext

func (*KeywordsCanBeIdContext) IsKeywordsCanBeIdContext()

func (*KeywordsCanBeIdContext) JIS

func (*KeywordsCanBeIdContext) JSON

func (*KeywordsCanBeIdContext) KEY

func (*KeywordsCanBeIdContext) KEY_BLOCK_SIZE

func (s *KeywordsCanBeIdContext) KEY_BLOCK_SIZE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) LANGUAGE

func (*KeywordsCanBeIdContext) LAST

func (*KeywordsCanBeIdContext) LEAVES

func (*KeywordsCanBeIdContext) LESS

func (*KeywordsCanBeIdContext) LEVEL

func (*KeywordsCanBeIdContext) LIST

func (*KeywordsCanBeIdContext) LOCAL

func (*KeywordsCanBeIdContext) LOGFILE

func (*KeywordsCanBeIdContext) LOGS

func (*KeywordsCanBeIdContext) MAINTAIN_STATS_PROBABILITY

func (s *KeywordsCanBeIdContext) MAINTAIN_STATS_PROBABILITY() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER

func (*KeywordsCanBeIdContext) MASTER_AUTO_POSITION

func (s *KeywordsCanBeIdContext) MASTER_AUTO_POSITION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_CONNECT_RETRY

func (s *KeywordsCanBeIdContext) MASTER_CONNECT_RETRY() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_DELAY

func (s *KeywordsCanBeIdContext) MASTER_DELAY() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_HEARTBEAT_PERIOD

func (s *KeywordsCanBeIdContext) MASTER_HEARTBEAT_PERIOD() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_HOST

func (s *KeywordsCanBeIdContext) MASTER_HOST() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_LOG_FILE

func (s *KeywordsCanBeIdContext) MASTER_LOG_FILE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_LOG_POS

func (s *KeywordsCanBeIdContext) MASTER_LOG_POS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_PASSWORD

func (s *KeywordsCanBeIdContext) MASTER_PASSWORD() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_PORT

func (s *KeywordsCanBeIdContext) MASTER_PORT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_RETRY_COUNT

func (s *KeywordsCanBeIdContext) MASTER_RETRY_COUNT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_SSL

func (s *KeywordsCanBeIdContext) MASTER_SSL() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_SSL_CA

func (s *KeywordsCanBeIdContext) MASTER_SSL_CA() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_SSL_CAPATH

func (s *KeywordsCanBeIdContext) MASTER_SSL_CAPATH() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_SSL_CERT

func (s *KeywordsCanBeIdContext) MASTER_SSL_CERT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_SSL_CIPHER

func (s *KeywordsCanBeIdContext) MASTER_SSL_CIPHER() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_SSL_CRL

func (s *KeywordsCanBeIdContext) MASTER_SSL_CRL() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_SSL_CRLPATH

func (s *KeywordsCanBeIdContext) MASTER_SSL_CRLPATH() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_SSL_KEY

func (s *KeywordsCanBeIdContext) MASTER_SSL_KEY() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_TLS_VERSION

func (s *KeywordsCanBeIdContext) MASTER_TLS_VERSION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MASTER_USER

func (s *KeywordsCanBeIdContext) MASTER_USER() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MAX

func (*KeywordsCanBeIdContext) MAX_CONNECTIONS_PER_HOUR

func (s *KeywordsCanBeIdContext) MAX_CONNECTIONS_PER_HOUR() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MAX_QUERIES_PER_HOUR

func (s *KeywordsCanBeIdContext) MAX_QUERIES_PER_HOUR() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MAX_ROWS

func (*KeywordsCanBeIdContext) MAX_SIZE

func (*KeywordsCanBeIdContext) MAX_UPDATES_PER_HOUR

func (s *KeywordsCanBeIdContext) MAX_UPDATES_PER_HOUR() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MAX_USER_CONNECTIONS

func (s *KeywordsCanBeIdContext) MAX_USER_CONNECTIONS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) MEDIUM

func (*KeywordsCanBeIdContext) MEMBER

func (*KeywordsCanBeIdContext) MEMORY

func (*KeywordsCanBeIdContext) MERGE

func (*KeywordsCanBeIdContext) MESSAGE

func (*KeywordsCanBeIdContext) MESSAGE_TEXT

func (s *KeywordsCanBeIdContext) MESSAGE_TEXT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) METRIC

func (*KeywordsCanBeIdContext) MID

func (*KeywordsCanBeIdContext) MIGRATE

func (*KeywordsCanBeIdContext) MIN

func (*KeywordsCanBeIdContext) MIN_ROWS

func (*KeywordsCanBeIdContext) MODE

func (*KeywordsCanBeIdContext) MODIFY

func (*KeywordsCanBeIdContext) MUTEX

func (*KeywordsCanBeIdContext) MYSQL

func (*KeywordsCanBeIdContext) MYSQL_ERRNO

func (s *KeywordsCanBeIdContext) MYSQL_ERRNO() antlr.TerminalNode

func (*KeywordsCanBeIdContext) M_MAX

func (*KeywordsCanBeIdContext) M_MAX_0

func (*KeywordsCanBeIdContext) NAME

func (*KeywordsCanBeIdContext) NAMES

func (*KeywordsCanBeIdContext) NCHAR

func (*KeywordsCanBeIdContext) NDB_STORED_USER

func (s *KeywordsCanBeIdContext) NDB_STORED_USER() antlr.TerminalNode

func (*KeywordsCanBeIdContext) NEVER

func (*KeywordsCanBeIdContext) NEXT

func (*KeywordsCanBeIdContext) NO

func (*KeywordsCanBeIdContext) NOCACHE

func (*KeywordsCanBeIdContext) NOCOPY

func (*KeywordsCanBeIdContext) NODEGROUP

func (s *KeywordsCanBeIdContext) NODEGROUP() antlr.TerminalNode

func (*KeywordsCanBeIdContext) NONE

func (*KeywordsCanBeIdContext) NOWAIT

func (*KeywordsCanBeIdContext) NUMBER

func (*KeywordsCanBeIdContext) ODBC

func (*KeywordsCanBeIdContext) OF

func (*KeywordsCanBeIdContext) OFFLINE

func (*KeywordsCanBeIdContext) OFFSET

func (*KeywordsCanBeIdContext) OJ

func (*KeywordsCanBeIdContext) OLD_PASSWORD

func (s *KeywordsCanBeIdContext) OLD_PASSWORD() antlr.TerminalNode

func (*KeywordsCanBeIdContext) ONE

func (*KeywordsCanBeIdContext) ONLINE

func (*KeywordsCanBeIdContext) ONLY

func (*KeywordsCanBeIdContext) OPEN

func (*KeywordsCanBeIdContext) OPTIMIZER_COSTS

func (s *KeywordsCanBeIdContext) OPTIMIZER_COSTS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) OPTIONAL

func (*KeywordsCanBeIdContext) OPTIONS

func (*KeywordsCanBeIdContext) ORDER

func (*KeywordsCanBeIdContext) OWNER

func (*KeywordsCanBeIdContext) PACK_KEYS

func (s *KeywordsCanBeIdContext) PACK_KEYS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) PAGE

func (*KeywordsCanBeIdContext) PAGE_CHECKSUM

func (s *KeywordsCanBeIdContext) PAGE_CHECKSUM() antlr.TerminalNode

func (*KeywordsCanBeIdContext) PARSER

func (*KeywordsCanBeIdContext) PARTIAL

func (*KeywordsCanBeIdContext) PARTITIONING

func (s *KeywordsCanBeIdContext) PARTITIONING() antlr.TerminalNode

func (*KeywordsCanBeIdContext) PARTITIONS

func (s *KeywordsCanBeIdContext) PARTITIONS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) PASSWORD

func (*KeywordsCanBeIdContext) PERSIST_RO_VARIABLES_ADMIN

func (s *KeywordsCanBeIdContext) PERSIST_RO_VARIABLES_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) PHASE

func (*KeywordsCanBeIdContext) PLUGIN

func (*KeywordsCanBeIdContext) PLUGINS

func (*KeywordsCanBeIdContext) PLUGIN_DIR

func (s *KeywordsCanBeIdContext) PLUGIN_DIR() antlr.TerminalNode

func (*KeywordsCanBeIdContext) PORT

func (*KeywordsCanBeIdContext) PRECEDES

func (*KeywordsCanBeIdContext) PREPARE

func (*KeywordsCanBeIdContext) PRESERVE

func (*KeywordsCanBeIdContext) PREV

func (*KeywordsCanBeIdContext) PROCESSLIST

func (s *KeywordsCanBeIdContext) PROCESSLIST() antlr.TerminalNode

func (*KeywordsCanBeIdContext) PROFILE

func (*KeywordsCanBeIdContext) PROFILES

func (*KeywordsCanBeIdContext) PROXY

func (*KeywordsCanBeIdContext) QUERY

func (*KeywordsCanBeIdContext) QUICK

func (*KeywordsCanBeIdContext) RABITQ_NUM_EX_BITS

func (s *KeywordsCanBeIdContext) RABITQ_NUM_EX_BITS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) REBUILD

func (*KeywordsCanBeIdContext) RECOVER

func (*KeywordsCanBeIdContext) REDO_BUFFER_SIZE

func (s *KeywordsCanBeIdContext) REDO_BUFFER_SIZE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) REDUNDANT

func (s *KeywordsCanBeIdContext) REDUNDANT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) RELAY

func (*KeywordsCanBeIdContext) RELAYLOG

func (*KeywordsCanBeIdContext) RELAY_LOG_FILE

func (s *KeywordsCanBeIdContext) RELAY_LOG_FILE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) RELAY_LOG_POS

func (s *KeywordsCanBeIdContext) RELAY_LOG_POS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) REMOVE

func (*KeywordsCanBeIdContext) REORGANIZE

func (s *KeywordsCanBeIdContext) REORGANIZE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) REPAIR

func (*KeywordsCanBeIdContext) RESET

func (*KeywordsCanBeIdContext) RESOURCE_GROUP_ADMIN

func (s *KeywordsCanBeIdContext) RESOURCE_GROUP_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) RESOURCE_GROUP_USER

func (s *KeywordsCanBeIdContext) RESOURCE_GROUP_USER() antlr.TerminalNode

func (*KeywordsCanBeIdContext) RESPECT

func (*KeywordsCanBeIdContext) RESUME

func (*KeywordsCanBeIdContext) RETURNED_SQLSTATE

func (s *KeywordsCanBeIdContext) RETURNED_SQLSTATE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) RETURNS

func (*KeywordsCanBeIdContext) ROLE

func (*KeywordsCanBeIdContext) ROLE_ADMIN

func (s *KeywordsCanBeIdContext) ROLE_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) ROLLBACK

func (*KeywordsCanBeIdContext) ROLLUP

func (*KeywordsCanBeIdContext) ROTATE

func (*KeywordsCanBeIdContext) ROW

func (*KeywordsCanBeIdContext) ROWS

func (*KeywordsCanBeIdContext) ROW_FORMAT

func (s *KeywordsCanBeIdContext) ROW_FORMAT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) RTREE

func (*KeywordsCanBeIdContext) SAMPLE_VECTOR_STATS_PROBABILITY

func (s *KeywordsCanBeIdContext) SAMPLE_VECTOR_STATS_PROBABILITY() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SAVEPOINT

func (s *KeywordsCanBeIdContext) SAVEPOINT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SCHEDULE

func (*KeywordsCanBeIdContext) SCHEMA

func (*KeywordsCanBeIdContext) SCHEMAS

func (*KeywordsCanBeIdContext) SCHEMA_NAME

func (s *KeywordsCanBeIdContext) SCHEMA_NAME() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SECONDARY_ENGINE_ATTRIBUTE

func (s *KeywordsCanBeIdContext) SECONDARY_ENGINE_ATTRIBUTE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SECURITY

func (*KeywordsCanBeIdContext) SERIAL

func (*KeywordsCanBeIdContext) SERVER

func (*KeywordsCanBeIdContext) SESSION

func (*KeywordsCanBeIdContext) SESSION_VARIABLES_ADMIN

func (s *KeywordsCanBeIdContext) SESSION_VARIABLES_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SET_USER_ID

func (s *KeywordsCanBeIdContext) SET_USER_ID() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SHARE

func (*KeywordsCanBeIdContext) SHARED

func (*KeywordsCanBeIdContext) SHOW_ROUTINE

func (s *KeywordsCanBeIdContext) SHOW_ROUTINE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SIGNED

func (*KeywordsCanBeIdContext) SIMPLE

func (*KeywordsCanBeIdContext) SLAVE

func (*KeywordsCanBeIdContext) SLOW

func (*KeywordsCanBeIdContext) SNAPSHOT

func (*KeywordsCanBeIdContext) SOCKET

func (*KeywordsCanBeIdContext) SOME

func (*KeywordsCanBeIdContext) SONAME

func (*KeywordsCanBeIdContext) SOUNDS

func (*KeywordsCanBeIdContext) SOURCE

func (*KeywordsCanBeIdContext) SQL_AFTER_GTIDS

func (s *KeywordsCanBeIdContext) SQL_AFTER_GTIDS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SQL_AFTER_MTS_GAPS

func (s *KeywordsCanBeIdContext) SQL_AFTER_MTS_GAPS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SQL_BEFORE_GTIDS

func (s *KeywordsCanBeIdContext) SQL_BEFORE_GTIDS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SQL_BUFFER_RESULT

func (s *KeywordsCanBeIdContext) SQL_BUFFER_RESULT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SQL_THREAD

func (s *KeywordsCanBeIdContext) SQL_THREAD() antlr.TerminalNode

func (*KeywordsCanBeIdContext) STACKED

func (*KeywordsCanBeIdContext) START

func (*KeywordsCanBeIdContext) STARTS

func (*KeywordsCanBeIdContext) STATS_AUTO_RECALC

func (s *KeywordsCanBeIdContext) STATS_AUTO_RECALC() antlr.TerminalNode

func (*KeywordsCanBeIdContext) STATS_PERSISTENT

func (s *KeywordsCanBeIdContext) STATS_PERSISTENT() antlr.TerminalNode

func (*KeywordsCanBeIdContext) STATS_SAMPLE_PAGES

func (s *KeywordsCanBeIdContext) STATS_SAMPLE_PAGES() antlr.TerminalNode

func (*KeywordsCanBeIdContext) STATS_THRESHOLD

func (s *KeywordsCanBeIdContext) STATS_THRESHOLD() antlr.TerminalNode

func (*KeywordsCanBeIdContext) STATUS

func (*KeywordsCanBeIdContext) STD

func (*KeywordsCanBeIdContext) STDDEV

func (*KeywordsCanBeIdContext) STDDEV_POP

func (s *KeywordsCanBeIdContext) STDDEV_POP() antlr.TerminalNode

func (*KeywordsCanBeIdContext) STDDEV_SAMP

func (s *KeywordsCanBeIdContext) STDDEV_SAMP() antlr.TerminalNode

func (*KeywordsCanBeIdContext) STOP

func (*KeywordsCanBeIdContext) STORAGE

func (*KeywordsCanBeIdContext) SUBCLASS_ORIGIN

func (s *KeywordsCanBeIdContext) SUBCLASS_ORIGIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SUBJECT

func (*KeywordsCanBeIdContext) SUBPARTITION

func (s *KeywordsCanBeIdContext) SUBPARTITION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SUBPARTITIONS

func (s *KeywordsCanBeIdContext) SUBPARTITIONS() antlr.TerminalNode

func (*KeywordsCanBeIdContext) SUM

func (*KeywordsCanBeIdContext) SUSPEND

func (*KeywordsCanBeIdContext) SWAPS

func (*KeywordsCanBeIdContext) SWITCHES

func (*KeywordsCanBeIdContext) SYSTEM_VARIABLES_ADMIN

func (s *KeywordsCanBeIdContext) SYSTEM_VARIABLES_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) TABLESPACE

func (s *KeywordsCanBeIdContext) TABLESPACE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) TABLE_ENCRYPTION_ADMIN

func (s *KeywordsCanBeIdContext) TABLE_ENCRYPTION_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) TABLE_NAME

func (s *KeywordsCanBeIdContext) TABLE_NAME() antlr.TerminalNode

func (*KeywordsCanBeIdContext) TEMPORARY

func (s *KeywordsCanBeIdContext) TEMPORARY() antlr.TerminalNode

func (*KeywordsCanBeIdContext) TEMPTABLE

func (s *KeywordsCanBeIdContext) TEMPTABLE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) TEXT

func (*KeywordsCanBeIdContext) THAN

func (*KeywordsCanBeIdContext) TRADITIONAL

func (s *KeywordsCanBeIdContext) TRADITIONAL() antlr.TerminalNode

func (*KeywordsCanBeIdContext) TRANSACTION

func (s *KeywordsCanBeIdContext) TRANSACTION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) TRANSACTIONAL

func (s *KeywordsCanBeIdContext) TRANSACTIONAL() antlr.TerminalNode

func (*KeywordsCanBeIdContext) TRIGGERS

func (*KeywordsCanBeIdContext) TRUNCATE

func (*KeywordsCanBeIdContext) ToStringTree

func (s *KeywordsCanBeIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*KeywordsCanBeIdContext) UNDEFINED

func (s *KeywordsCanBeIdContext) UNDEFINED() antlr.TerminalNode

func (*KeywordsCanBeIdContext) UNDOFILE

func (*KeywordsCanBeIdContext) UNDO_BUFFER_SIZE

func (s *KeywordsCanBeIdContext) UNDO_BUFFER_SIZE() antlr.TerminalNode

func (*KeywordsCanBeIdContext) UNINSTALL

func (s *KeywordsCanBeIdContext) UNINSTALL() antlr.TerminalNode

func (*KeywordsCanBeIdContext) UNKNOWN

func (*KeywordsCanBeIdContext) UNTIL

func (*KeywordsCanBeIdContext) UPGRADE

func (*KeywordsCanBeIdContext) USA

func (*KeywordsCanBeIdContext) USER

func (*KeywordsCanBeIdContext) USER_RESOURCES

func (s *KeywordsCanBeIdContext) USER_RESOURCES() antlr.TerminalNode

func (*KeywordsCanBeIdContext) USE_FRM

func (*KeywordsCanBeIdContext) USE_RABITQ

func (s *KeywordsCanBeIdContext) USE_RABITQ() antlr.TerminalNode

func (*KeywordsCanBeIdContext) VALIDATION

func (s *KeywordsCanBeIdContext) VALIDATION() antlr.TerminalNode

func (*KeywordsCanBeIdContext) VALUE

func (*KeywordsCanBeIdContext) VARIABLES

func (s *KeywordsCanBeIdContext) VARIABLES() antlr.TerminalNode

func (*KeywordsCanBeIdContext) VARIANCE

func (*KeywordsCanBeIdContext) VAR_POP

func (*KeywordsCanBeIdContext) VAR_SAMP

func (*KeywordsCanBeIdContext) VERSION_TOKEN_ADMIN

func (s *KeywordsCanBeIdContext) VERSION_TOKEN_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) VIEW

func (*KeywordsCanBeIdContext) WAIT

func (*KeywordsCanBeIdContext) WARNINGS

func (*KeywordsCanBeIdContext) WITHOUT

func (*KeywordsCanBeIdContext) WRAPPER

func (*KeywordsCanBeIdContext) X509

func (*KeywordsCanBeIdContext) XA

func (*KeywordsCanBeIdContext) XA_RECOVER_ADMIN

func (s *KeywordsCanBeIdContext) XA_RECOVER_ADMIN() antlr.TerminalNode

func (*KeywordsCanBeIdContext) XML

type KillStatementContext

type KillStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyKillStatementContext

func NewEmptyKillStatementContext() *KillStatementContext

func NewKillStatementContext

func NewKillStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KillStatementContext

func (*KillStatementContext) Accept

func (s *KillStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*KillStatementContext) AllDecimalLiteral

func (s *KillStatementContext) AllDecimalLiteral() []IDecimalLiteralContext

func (*KillStatementContext) CONNECTION

func (s *KillStatementContext) CONNECTION() antlr.TerminalNode

func (*KillStatementContext) DecimalLiteral

func (s *KillStatementContext) DecimalLiteral(i int) IDecimalLiteralContext

func (*KillStatementContext) EnterRule

func (s *KillStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*KillStatementContext) ExitRule

func (s *KillStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*KillStatementContext) GetConnectionFormat

func (s *KillStatementContext) GetConnectionFormat() antlr.Token

func (*KillStatementContext) GetParser

func (s *KillStatementContext) GetParser() antlr.Parser

func (*KillStatementContext) GetRuleContext

func (s *KillStatementContext) GetRuleContext() antlr.RuleContext

func (*KillStatementContext) IsKillStatementContext

func (*KillStatementContext) IsKillStatementContext()

func (*KillStatementContext) KILL

func (*KillStatementContext) QUERY

func (*KillStatementContext) SetConnectionFormat

func (s *KillStatementContext) SetConnectionFormat(v antlr.Token)

func (*KillStatementContext) ToStringTree

func (s *KillStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LanguageClauseContext

type LanguageClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLanguageClauseContext

func NewEmptyLanguageClauseContext() *LanguageClauseContext

func NewLanguageClauseContext

func NewLanguageClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LanguageClauseContext

func (*LanguageClauseContext) Accept

func (s *LanguageClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LanguageClauseContext) EnterRule

func (s *LanguageClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*LanguageClauseContext) ExitRule

func (s *LanguageClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*LanguageClauseContext) GetParser

func (s *LanguageClauseContext) GetParser() antlr.Parser

func (*LanguageClauseContext) GetRuleContext

func (s *LanguageClauseContext) GetRuleContext() antlr.RuleContext

func (*LanguageClauseContext) IsLanguageClauseContext

func (*LanguageClauseContext) IsLanguageClauseContext()

func (*LanguageClauseContext) LANGUAGE

func (*LanguageClauseContext) LanguageName

func (s *LanguageClauseContext) LanguageName() ILanguageNameContext

func (*LanguageClauseContext) ToStringTree

func (s *LanguageClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LanguageNameContext

type LanguageNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLanguageNameContext

func NewEmptyLanguageNameContext() *LanguageNameContext

func NewLanguageNameContext

func NewLanguageNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LanguageNameContext

func (*LanguageNameContext) Accept

func (s *LanguageNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LanguageNameContext) EnterRule

func (s *LanguageNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*LanguageNameContext) ExitRule

func (s *LanguageNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*LanguageNameContext) GetParser

func (s *LanguageNameContext) GetParser() antlr.Parser

func (*LanguageNameContext) GetRuleContext

func (s *LanguageNameContext) GetRuleContext() antlr.RuleContext

func (*LanguageNameContext) IsLanguageNameContext

func (*LanguageNameContext) IsLanguageNameContext()

func (*LanguageNameContext) JAVA

func (*LanguageNameContext) SQL

func (*LanguageNameContext) ToStringTree

func (s *LanguageNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LengthOneDimensionContext

type LengthOneDimensionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLengthOneDimensionContext

func NewEmptyLengthOneDimensionContext() *LengthOneDimensionContext

func NewLengthOneDimensionContext

func NewLengthOneDimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LengthOneDimensionContext

func (*LengthOneDimensionContext) Accept

func (s *LengthOneDimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LengthOneDimensionContext) DecimalLiteral

func (*LengthOneDimensionContext) EnterRule

func (s *LengthOneDimensionContext) EnterRule(listener antlr.ParseTreeListener)

func (*LengthOneDimensionContext) ExitRule

func (s *LengthOneDimensionContext) ExitRule(listener antlr.ParseTreeListener)

func (*LengthOneDimensionContext) GetParser

func (s *LengthOneDimensionContext) GetParser() antlr.Parser

func (*LengthOneDimensionContext) GetRuleContext

func (s *LengthOneDimensionContext) GetRuleContext() antlr.RuleContext

func (*LengthOneDimensionContext) IsLengthOneDimensionContext

func (*LengthOneDimensionContext) IsLengthOneDimensionContext()

func (*LengthOneDimensionContext) LEFT_ROUND_BRACKET

func (s *LengthOneDimensionContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*LengthOneDimensionContext) RIGHT_ROUND_BRACKET

func (s *LengthOneDimensionContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*LengthOneDimensionContext) ToStringTree

func (s *LengthOneDimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LengthTwoDimensionContext

type LengthTwoDimensionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLengthTwoDimensionContext

func NewEmptyLengthTwoDimensionContext() *LengthTwoDimensionContext

func NewLengthTwoDimensionContext

func NewLengthTwoDimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LengthTwoDimensionContext

func (*LengthTwoDimensionContext) Accept

func (s *LengthTwoDimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LengthTwoDimensionContext) AllDecimalLiteral

func (s *LengthTwoDimensionContext) AllDecimalLiteral() []IDecimalLiteralContext

func (*LengthTwoDimensionContext) COMMA

func (*LengthTwoDimensionContext) DecimalLiteral

func (*LengthTwoDimensionContext) EnterRule

func (s *LengthTwoDimensionContext) EnterRule(listener antlr.ParseTreeListener)

func (*LengthTwoDimensionContext) ExitRule

func (s *LengthTwoDimensionContext) ExitRule(listener antlr.ParseTreeListener)

func (*LengthTwoDimensionContext) GetParser

func (s *LengthTwoDimensionContext) GetParser() antlr.Parser

func (*LengthTwoDimensionContext) GetRuleContext

func (s *LengthTwoDimensionContext) GetRuleContext() antlr.RuleContext

func (*LengthTwoDimensionContext) IsLengthTwoDimensionContext

func (*LengthTwoDimensionContext) IsLengthTwoDimensionContext()

func (*LengthTwoDimensionContext) LEFT_ROUND_BRACKET

func (s *LengthTwoDimensionContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*LengthTwoDimensionContext) RIGHT_ROUND_BRACKET

func (s *LengthTwoDimensionContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*LengthTwoDimensionContext) ToStringTree

func (s *LengthTwoDimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LengthTwoOptionalDimensionContext

type LengthTwoOptionalDimensionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLengthTwoOptionalDimensionContext

func NewEmptyLengthTwoOptionalDimensionContext() *LengthTwoOptionalDimensionContext

func NewLengthTwoOptionalDimensionContext

func NewLengthTwoOptionalDimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LengthTwoOptionalDimensionContext

func (*LengthTwoOptionalDimensionContext) Accept

func (s *LengthTwoOptionalDimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LengthTwoOptionalDimensionContext) AllDecimalLiteral

func (*LengthTwoOptionalDimensionContext) COMMA

func (*LengthTwoOptionalDimensionContext) DecimalLiteral

func (*LengthTwoOptionalDimensionContext) EnterRule

func (*LengthTwoOptionalDimensionContext) ExitRule

func (*LengthTwoOptionalDimensionContext) GetParser

func (*LengthTwoOptionalDimensionContext) GetRuleContext

func (*LengthTwoOptionalDimensionContext) IsLengthTwoOptionalDimensionContext

func (*LengthTwoOptionalDimensionContext) IsLengthTwoOptionalDimensionContext()

func (*LengthTwoOptionalDimensionContext) LEFT_ROUND_BRACKET

func (s *LengthTwoOptionalDimensionContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*LengthTwoOptionalDimensionContext) RIGHT_ROUND_BRACKET

func (s *LengthTwoOptionalDimensionContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*LengthTwoOptionalDimensionContext) ToStringTree

func (s *LengthTwoOptionalDimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LevelInWeightListElementContext

type LevelInWeightListElementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLevelInWeightListElementContext

func NewEmptyLevelInWeightListElementContext() *LevelInWeightListElementContext

func NewLevelInWeightListElementContext

func NewLevelInWeightListElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LevelInWeightListElementContext

func (*LevelInWeightListElementContext) ASC

func (*LevelInWeightListElementContext) Accept

func (s *LevelInWeightListElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LevelInWeightListElementContext) DESC

func (*LevelInWeightListElementContext) DecimalLiteral

func (*LevelInWeightListElementContext) EnterRule

func (*LevelInWeightListElementContext) ExitRule

func (*LevelInWeightListElementContext) GetOrderType

func (s *LevelInWeightListElementContext) GetOrderType() antlr.Token

func (*LevelInWeightListElementContext) GetParser

func (*LevelInWeightListElementContext) GetRuleContext

func (*LevelInWeightListElementContext) IsLevelInWeightListElementContext

func (*LevelInWeightListElementContext) IsLevelInWeightListElementContext()

func (*LevelInWeightListElementContext) REVERSE

func (*LevelInWeightListElementContext) SetOrderType

func (s *LevelInWeightListElementContext) SetOrderType(v antlr.Token)

func (*LevelInWeightListElementContext) ToStringTree

func (s *LevelInWeightListElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LevelWeightListContext

type LevelWeightListContext struct {
	LevelsInWeightStringContext
}

func NewLevelWeightListContext

func NewLevelWeightListContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LevelWeightListContext

func (*LevelWeightListContext) Accept

func (s *LevelWeightListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LevelWeightListContext) AllCOMMA

func (s *LevelWeightListContext) AllCOMMA() []antlr.TerminalNode

func (*LevelWeightListContext) AllLevelInWeightListElement

func (s *LevelWeightListContext) AllLevelInWeightListElement() []ILevelInWeightListElementContext

func (*LevelWeightListContext) COMMA

func (*LevelWeightListContext) EnterRule

func (s *LevelWeightListContext) EnterRule(listener antlr.ParseTreeListener)

func (*LevelWeightListContext) ExitRule

func (s *LevelWeightListContext) ExitRule(listener antlr.ParseTreeListener)

func (*LevelWeightListContext) GetRuleContext

func (s *LevelWeightListContext) GetRuleContext() antlr.RuleContext

func (*LevelWeightListContext) LEVEL

func (*LevelWeightListContext) LevelInWeightListElement

func (s *LevelWeightListContext) LevelInWeightListElement(i int) ILevelInWeightListElementContext

type LevelWeightRangeContext

type LevelWeightRangeContext struct {
	LevelsInWeightStringContext
	// contains filtered or unexported fields
}

func NewLevelWeightRangeContext

func NewLevelWeightRangeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LevelWeightRangeContext

func (*LevelWeightRangeContext) Accept

func (s *LevelWeightRangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LevelWeightRangeContext) AllDecimalLiteral

func (s *LevelWeightRangeContext) AllDecimalLiteral() []IDecimalLiteralContext

func (*LevelWeightRangeContext) DecimalLiteral

func (s *LevelWeightRangeContext) DecimalLiteral(i int) IDecimalLiteralContext

func (*LevelWeightRangeContext) EnterRule

func (s *LevelWeightRangeContext) EnterRule(listener antlr.ParseTreeListener)

func (*LevelWeightRangeContext) ExitRule

func (s *LevelWeightRangeContext) ExitRule(listener antlr.ParseTreeListener)

func (*LevelWeightRangeContext) GetFirstLevel

func (*LevelWeightRangeContext) GetLastLevel

func (*LevelWeightRangeContext) GetRuleContext

func (s *LevelWeightRangeContext) GetRuleContext() antlr.RuleContext

func (*LevelWeightRangeContext) LEVEL

func (*LevelWeightRangeContext) MINUS

func (*LevelWeightRangeContext) SetFirstLevel

func (s *LevelWeightRangeContext) SetFirstLevel(v IDecimalLiteralContext)

func (*LevelWeightRangeContext) SetLastLevel

type LevelsInWeightStringContext

type LevelsInWeightStringContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLevelsInWeightStringContext

func NewEmptyLevelsInWeightStringContext() *LevelsInWeightStringContext

func NewLevelsInWeightStringContext

func NewLevelsInWeightStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LevelsInWeightStringContext

func (*LevelsInWeightStringContext) CopyAll

func (*LevelsInWeightStringContext) GetParser

func (s *LevelsInWeightStringContext) GetParser() antlr.Parser

func (*LevelsInWeightStringContext) GetRuleContext

func (s *LevelsInWeightStringContext) GetRuleContext() antlr.RuleContext

func (*LevelsInWeightStringContext) IsLevelsInWeightStringContext

func (*LevelsInWeightStringContext) IsLevelsInWeightStringContext()

func (*LevelsInWeightStringContext) ToStringTree

func (s *LevelsInWeightStringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LikePredicateContext

type LikePredicateContext struct {
	PredicateContext
	// contains filtered or unexported fields
}

func NewLikePredicateContext

func NewLikePredicateContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LikePredicateContext

func (*LikePredicateContext) Accept

func (s *LikePredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LikePredicateContext) Constant

func (s *LikePredicateContext) Constant() IConstantContext

func (*LikePredicateContext) ESCAPE

func (*LikePredicateContext) EnterRule

func (s *LikePredicateContext) EnterRule(listener antlr.ParseTreeListener)

func (*LikePredicateContext) ExitRule

func (s *LikePredicateContext) ExitRule(listener antlr.ParseTreeListener)

func (*LikePredicateContext) GetEscape

func (s *LikePredicateContext) GetEscape() antlr.Token

func (*LikePredicateContext) GetPattern

func (s *LikePredicateContext) GetPattern() IConstantContext

func (*LikePredicateContext) GetRuleContext

func (s *LikePredicateContext) GetRuleContext() antlr.RuleContext

func (*LikePredicateContext) LIKE

func (*LikePredicateContext) NOT

func (*LikePredicateContext) STRING_LITERAL

func (s *LikePredicateContext) STRING_LITERAL() antlr.TerminalNode

func (*LikePredicateContext) SetEscape

func (s *LikePredicateContext) SetEscape(v antlr.Token)

func (*LikePredicateContext) SetPattern

func (s *LikePredicateContext) SetPattern(v IConstantContext)

type LimitClauseAtomContext

type LimitClauseAtomContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLimitClauseAtomContext

func NewEmptyLimitClauseAtomContext() *LimitClauseAtomContext

func NewLimitClauseAtomContext

func NewLimitClauseAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseAtomContext

func (*LimitClauseAtomContext) Accept

func (s *LimitClauseAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LimitClauseAtomContext) DecimalLiteral

func (s *LimitClauseAtomContext) DecimalLiteral() IDecimalLiteralContext

func (*LimitClauseAtomContext) EnterRule

func (s *LimitClauseAtomContext) EnterRule(listener antlr.ParseTreeListener)

func (*LimitClauseAtomContext) ExitRule

func (s *LimitClauseAtomContext) ExitRule(listener antlr.ParseTreeListener)

func (*LimitClauseAtomContext) GetParser

func (s *LimitClauseAtomContext) GetParser() antlr.Parser

func (*LimitClauseAtomContext) GetRuleContext

func (s *LimitClauseAtomContext) GetRuleContext() antlr.RuleContext

func (*LimitClauseAtomContext) IsLimitClauseAtomContext

func (*LimitClauseAtomContext) IsLimitClauseAtomContext()

func (*LimitClauseAtomContext) PreparedStatementParameter

func (s *LimitClauseAtomContext) PreparedStatementParameter() IPreparedStatementParameterContext

func (*LimitClauseAtomContext) ToStringTree

func (s *LimitClauseAtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LimitClauseContext

type LimitClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLimitClauseContext

func NewEmptyLimitClauseContext() *LimitClauseContext

func NewLimitClauseContext

func NewLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseContext

func (*LimitClauseContext) Accept

func (s *LimitClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LimitClauseContext) AllLimitClauseAtom

func (s *LimitClauseContext) AllLimitClauseAtom() []ILimitClauseAtomContext

func (*LimitClauseContext) EnterRule

func (s *LimitClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*LimitClauseContext) ExitRule

func (s *LimitClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*LimitClauseContext) GetLimit

func (*LimitClauseContext) GetOffset

func (*LimitClauseContext) GetParser

func (s *LimitClauseContext) GetParser() antlr.Parser

func (*LimitClauseContext) GetRuleContext

func (s *LimitClauseContext) GetRuleContext() antlr.RuleContext

func (*LimitClauseContext) IsLimitClauseContext

func (*LimitClauseContext) IsLimitClauseContext()

func (*LimitClauseContext) LIMIT

func (*LimitClauseContext) LimitClauseAtom

func (s *LimitClauseContext) LimitClauseAtom(i int) ILimitClauseAtomContext

func (*LimitClauseContext) OFFSET

func (*LimitClauseContext) SetLimit

func (*LimitClauseContext) SetOffset

func (*LimitClauseContext) ToStringTree

func (s *LimitClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LoadedTableIndexesContext

type LoadedTableIndexesContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLoadedTableIndexesContext

func NewEmptyLoadedTableIndexesContext() *LoadedTableIndexesContext

func NewLoadedTableIndexesContext

func NewLoadedTableIndexesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadedTableIndexesContext

func (*LoadedTableIndexesContext) ALL

func (*LoadedTableIndexesContext) Accept

func (s *LoadedTableIndexesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LoadedTableIndexesContext) AllLEFT_ROUND_BRACKET

func (s *LoadedTableIndexesContext) AllLEFT_ROUND_BRACKET() []antlr.TerminalNode

func (*LoadedTableIndexesContext) AllRIGHT_ROUND_BRACKET

func (s *LoadedTableIndexesContext) AllRIGHT_ROUND_BRACKET() []antlr.TerminalNode

func (*LoadedTableIndexesContext) AllUidList

func (s *LoadedTableIndexesContext) AllUidList() []IUidListContext

func (*LoadedTableIndexesContext) EnterRule

func (s *LoadedTableIndexesContext) EnterRule(listener antlr.ParseTreeListener)

func (*LoadedTableIndexesContext) ExitRule

func (s *LoadedTableIndexesContext) ExitRule(listener antlr.ParseTreeListener)

func (*LoadedTableIndexesContext) GetIndexFormat

func (s *LoadedTableIndexesContext) GetIndexFormat() antlr.Token

func (*LoadedTableIndexesContext) GetIndexList

func (s *LoadedTableIndexesContext) GetIndexList() IUidListContext

func (*LoadedTableIndexesContext) GetParser

func (s *LoadedTableIndexesContext) GetParser() antlr.Parser

func (*LoadedTableIndexesContext) GetPartitionList

func (s *LoadedTableIndexesContext) GetPartitionList() IUidListContext

func (*LoadedTableIndexesContext) GetRuleContext

func (s *LoadedTableIndexesContext) GetRuleContext() antlr.RuleContext

func (*LoadedTableIndexesContext) IGNORE

func (*LoadedTableIndexesContext) INDEX

func (*LoadedTableIndexesContext) IsLoadedTableIndexesContext

func (*LoadedTableIndexesContext) IsLoadedTableIndexesContext()

func (*LoadedTableIndexesContext) KEY

func (*LoadedTableIndexesContext) LEAVES

func (*LoadedTableIndexesContext) LEFT_ROUND_BRACKET

func (s *LoadedTableIndexesContext) LEFT_ROUND_BRACKET(i int) antlr.TerminalNode

func (*LoadedTableIndexesContext) PARTITION

func (*LoadedTableIndexesContext) RIGHT_ROUND_BRACKET

func (s *LoadedTableIndexesContext) RIGHT_ROUND_BRACKET(i int) antlr.TerminalNode

func (*LoadedTableIndexesContext) SetIndexFormat

func (s *LoadedTableIndexesContext) SetIndexFormat(v antlr.Token)

func (*LoadedTableIndexesContext) SetIndexList

func (s *LoadedTableIndexesContext) SetIndexList(v IUidListContext)

func (*LoadedTableIndexesContext) SetPartitionList

func (s *LoadedTableIndexesContext) SetPartitionList(v IUidListContext)

func (*LoadedTableIndexesContext) TableName

func (*LoadedTableIndexesContext) ToStringTree

func (s *LoadedTableIndexesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*LoadedTableIndexesContext) UidList

type LogicalExpressionContext

type LogicalExpressionContext struct {
	ExpressionContext
}

func NewLogicalExpressionContext

func NewLogicalExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LogicalExpressionContext

func (*LogicalExpressionContext) Accept

func (s *LogicalExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LogicalExpressionContext) AllExpression

func (s *LogicalExpressionContext) AllExpression() []IExpressionContext

func (*LogicalExpressionContext) EnterRule

func (s *LogicalExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*LogicalExpressionContext) ExitRule

func (s *LogicalExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*LogicalExpressionContext) Expression

func (*LogicalExpressionContext) GetRuleContext

func (s *LogicalExpressionContext) GetRuleContext() antlr.RuleContext

func (*LogicalExpressionContext) LogicalOperator

type LogicalOperatorContext

type LogicalOperatorContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLogicalOperatorContext

func NewEmptyLogicalOperatorContext() *LogicalOperatorContext

func NewLogicalOperatorContext

func NewLogicalOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalOperatorContext

func (*LogicalOperatorContext) AND

func (*LogicalOperatorContext) Accept

func (s *LogicalOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LogicalOperatorContext) AllBIT_AND_OP

func (s *LogicalOperatorContext) AllBIT_AND_OP() []antlr.TerminalNode

func (*LogicalOperatorContext) AllBIT_OR_OP

func (s *LogicalOperatorContext) AllBIT_OR_OP() []antlr.TerminalNode

func (*LogicalOperatorContext) BIT_AND_OP

func (s *LogicalOperatorContext) BIT_AND_OP(i int) antlr.TerminalNode

func (*LogicalOperatorContext) BIT_OR_OP

func (s *LogicalOperatorContext) BIT_OR_OP(i int) antlr.TerminalNode

func (*LogicalOperatorContext) EnterRule

func (s *LogicalOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*LogicalOperatorContext) ExitRule

func (s *LogicalOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*LogicalOperatorContext) GetParser

func (s *LogicalOperatorContext) GetParser() antlr.Parser

func (*LogicalOperatorContext) GetRuleContext

func (s *LogicalOperatorContext) GetRuleContext() antlr.RuleContext

func (*LogicalOperatorContext) IsLogicalOperatorContext

func (*LogicalOperatorContext) IsLogicalOperatorContext()

func (*LogicalOperatorContext) OR

func (*LogicalOperatorContext) ToStringTree

func (s *LogicalOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*LogicalOperatorContext) XOR

type LongVarbinaryDataTypeContext

type LongVarbinaryDataTypeContext struct {
	DataTypeContext
}

func NewLongVarbinaryDataTypeContext

func NewLongVarbinaryDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LongVarbinaryDataTypeContext

func (*LongVarbinaryDataTypeContext) Accept

func (s *LongVarbinaryDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LongVarbinaryDataTypeContext) EnterRule

func (s *LongVarbinaryDataTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*LongVarbinaryDataTypeContext) ExitRule

func (*LongVarbinaryDataTypeContext) GetRuleContext

func (s *LongVarbinaryDataTypeContext) GetRuleContext() antlr.RuleContext

func (*LongVarbinaryDataTypeContext) LONG

func (*LongVarbinaryDataTypeContext) VARBINARY

type LongVarcharDataTypeContext

type LongVarcharDataTypeContext struct {
	DataTypeContext
	// contains filtered or unexported fields
}

func NewLongVarcharDataTypeContext

func NewLongVarcharDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *LongVarcharDataTypeContext

func (*LongVarcharDataTypeContext) Accept

func (s *LongVarcharDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LongVarcharDataTypeContext) BINARY

func (*LongVarcharDataTypeContext) COLLATE

func (*LongVarcharDataTypeContext) CharSet

func (*LongVarcharDataTypeContext) CharsetName

func (*LongVarcharDataTypeContext) CollationName

func (*LongVarcharDataTypeContext) EnterRule

func (s *LongVarcharDataTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*LongVarcharDataTypeContext) ExitRule

func (s *LongVarcharDataTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*LongVarcharDataTypeContext) GetRuleContext

func (s *LongVarcharDataTypeContext) GetRuleContext() antlr.RuleContext

func (*LongVarcharDataTypeContext) GetTypeName

func (s *LongVarcharDataTypeContext) GetTypeName() antlr.Token

func (*LongVarcharDataTypeContext) LONG

func (*LongVarcharDataTypeContext) SetTypeName

func (s *LongVarcharDataTypeContext) SetTypeName(v antlr.Token)

func (*LongVarcharDataTypeContext) VARCHAR

type MathExpressionAtomContext

type MathExpressionAtomContext struct {
	ExpressionAtomContext
	// contains filtered or unexported fields
}

func NewMathExpressionAtomContext

func NewMathExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MathExpressionAtomContext

func (*MathExpressionAtomContext) Accept

func (s *MathExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MathExpressionAtomContext) AllExpressionAtom

func (s *MathExpressionAtomContext) AllExpressionAtom() []IExpressionAtomContext

func (*MathExpressionAtomContext) EnterRule

func (s *MathExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener)

func (*MathExpressionAtomContext) ExitRule

func (s *MathExpressionAtomContext) ExitRule(listener antlr.ParseTreeListener)

func (*MathExpressionAtomContext) ExpressionAtom

func (*MathExpressionAtomContext) GetLeft

func (*MathExpressionAtomContext) GetRight

func (*MathExpressionAtomContext) GetRuleContext

func (s *MathExpressionAtomContext) GetRuleContext() antlr.RuleContext

func (*MathExpressionAtomContext) MathOperator

func (*MathExpressionAtomContext) SetLeft

func (*MathExpressionAtomContext) SetRight

type MathOperatorContext

type MathOperatorContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMathOperatorContext

func NewEmptyMathOperatorContext() *MathOperatorContext

func NewMathOperatorContext

func NewMathOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MathOperatorContext

func (*MathOperatorContext) Accept

func (s *MathOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MathOperatorContext) DIV

func (*MathOperatorContext) DIVIDE

func (*MathOperatorContext) EnterRule

func (s *MathOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*MathOperatorContext) ExitRule

func (s *MathOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*MathOperatorContext) GetParser

func (s *MathOperatorContext) GetParser() antlr.Parser

func (*MathOperatorContext) GetRuleContext

func (s *MathOperatorContext) GetRuleContext() antlr.RuleContext

func (*MathOperatorContext) IsMathOperatorContext

func (*MathOperatorContext) IsMathOperatorContext()

func (*MathOperatorContext) MINUS

func (*MathOperatorContext) MOD

func (*MathOperatorContext) MODULE

func (*MathOperatorContext) PLUS

func (*MathOperatorContext) STAR

func (*MathOperatorContext) ToStringTree

func (s *MathOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NamedFunctionArgContext

type NamedFunctionArgContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNamedFunctionArgContext

func NewEmptyNamedFunctionArgContext() *NamedFunctionArgContext

func NewNamedFunctionArgContext

func NewNamedFunctionArgContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedFunctionArgContext

func (*NamedFunctionArgContext) Accept

func (s *NamedFunctionArgContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NamedFunctionArgContext) EnterRule

func (s *NamedFunctionArgContext) EnterRule(listener antlr.ParseTreeListener)

func (*NamedFunctionArgContext) ExitRule

func (s *NamedFunctionArgContext) ExitRule(listener antlr.ParseTreeListener)

func (*NamedFunctionArgContext) Expression

func (*NamedFunctionArgContext) GetKey

func (*NamedFunctionArgContext) GetParser

func (s *NamedFunctionArgContext) GetParser() antlr.Parser

func (*NamedFunctionArgContext) GetRuleContext

func (s *NamedFunctionArgContext) GetRuleContext() antlr.RuleContext

func (*NamedFunctionArgContext) GetValue

func (*NamedFunctionArgContext) IsNamedFunctionArgContext

func (*NamedFunctionArgContext) IsNamedFunctionArgContext()

func (*NamedFunctionArgContext) NAMED_ARG_ASSIGN_TOKEN

func (s *NamedFunctionArgContext) NAMED_ARG_ASSIGN_TOKEN() antlr.TerminalNode

func (*NamedFunctionArgContext) SetKey

func (s *NamedFunctionArgContext) SetKey(v IUidContext)

func (*NamedFunctionArgContext) SetValue

func (*NamedFunctionArgContext) ToStringTree

func (s *NamedFunctionArgContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*NamedFunctionArgContext) Uid

type NamedOrUnnamedFunctionArgsContext

type NamedOrUnnamedFunctionArgsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNamedOrUnnamedFunctionArgsContext

func NewEmptyNamedOrUnnamedFunctionArgsContext() *NamedOrUnnamedFunctionArgsContext

func NewNamedOrUnnamedFunctionArgsContext

func NewNamedOrUnnamedFunctionArgsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedOrUnnamedFunctionArgsContext

func (*NamedOrUnnamedFunctionArgsContext) Accept

func (s *NamedOrUnnamedFunctionArgsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NamedOrUnnamedFunctionArgsContext) AllCOMMA

func (*NamedOrUnnamedFunctionArgsContext) AllFunctionArg

func (*NamedOrUnnamedFunctionArgsContext) AllNamedFunctionArg

func (*NamedOrUnnamedFunctionArgsContext) COMMA

func (*NamedOrUnnamedFunctionArgsContext) EnterRule

func (*NamedOrUnnamedFunctionArgsContext) ExitRule

func (*NamedOrUnnamedFunctionArgsContext) FunctionArg

func (*NamedOrUnnamedFunctionArgsContext) GetParser

func (*NamedOrUnnamedFunctionArgsContext) GetRuleContext

func (*NamedOrUnnamedFunctionArgsContext) IsNamedOrUnnamedFunctionArgsContext

func (*NamedOrUnnamedFunctionArgsContext) IsNamedOrUnnamedFunctionArgsContext()

func (*NamedOrUnnamedFunctionArgsContext) NamedFunctionArg

func (*NamedOrUnnamedFunctionArgsContext) ToStringTree

func (s *NamedOrUnnamedFunctionArgsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NamedQueryContext

type NamedQueryContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNamedQueryContext

func NewEmptyNamedQueryContext() *NamedQueryContext

func NewNamedQueryContext

func NewNamedQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamedQueryContext

func (*NamedQueryContext) AS

func (*NamedQueryContext) Accept

func (s *NamedQueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NamedQueryContext) EnterRule

func (s *NamedQueryContext) EnterRule(listener antlr.ParseTreeListener)

func (*NamedQueryContext) ExitRule

func (s *NamedQueryContext) ExitRule(listener antlr.ParseTreeListener)

func (*NamedQueryContext) FullId

func (s *NamedQueryContext) FullId() IFullIdContext

func (*NamedQueryContext) FullIdList

func (s *NamedQueryContext) FullIdList() IFullIdListContext

func (*NamedQueryContext) GetColumnAliases

func (s *NamedQueryContext) GetColumnAliases() IFullIdListContext

func (*NamedQueryContext) GetName

func (s *NamedQueryContext) GetName() IFullIdContext

func (*NamedQueryContext) GetParser

func (s *NamedQueryContext) GetParser() antlr.Parser

func (*NamedQueryContext) GetRuleContext

func (s *NamedQueryContext) GetRuleContext() antlr.RuleContext

func (*NamedQueryContext) IsNamedQueryContext

func (*NamedQueryContext) IsNamedQueryContext()

func (*NamedQueryContext) LEFT_ROUND_BRACKET

func (s *NamedQueryContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*NamedQueryContext) Query

func (s *NamedQueryContext) Query() IQueryContext

func (*NamedQueryContext) RIGHT_ROUND_BRACKET

func (s *NamedQueryContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*NamedQueryContext) SetColumnAliases

func (s *NamedQueryContext) SetColumnAliases(v IFullIdListContext)

func (*NamedQueryContext) SetName

func (s *NamedQueryContext) SetName(v IFullIdContext)

func (*NamedQueryContext) ToStringTree

func (s *NamedQueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NationalStringDataTypeContext

type NationalStringDataTypeContext struct {
	DataTypeContext
	// contains filtered or unexported fields
}

func NewNationalStringDataTypeContext

func NewNationalStringDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NationalStringDataTypeContext

func (*NationalStringDataTypeContext) Accept

func (s *NationalStringDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NationalStringDataTypeContext) BINARY

func (*NationalStringDataTypeContext) CHARACTER

func (*NationalStringDataTypeContext) EnterRule

func (s *NationalStringDataTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*NationalStringDataTypeContext) ExitRule

func (*NationalStringDataTypeContext) GetRuleContext

func (s *NationalStringDataTypeContext) GetRuleContext() antlr.RuleContext

func (*NationalStringDataTypeContext) GetTypeName

func (s *NationalStringDataTypeContext) GetTypeName() antlr.Token

func (*NationalStringDataTypeContext) LengthOneDimension

func (*NationalStringDataTypeContext) NATIONAL

func (*NationalStringDataTypeContext) NCHAR

func (*NationalStringDataTypeContext) SetTypeName

func (s *NationalStringDataTypeContext) SetTypeName(v antlr.Token)

func (*NationalStringDataTypeContext) VARCHAR

type NationalVaryingStringDataTypeContext

type NationalVaryingStringDataTypeContext struct {
	DataTypeContext
	// contains filtered or unexported fields
}

func (*NationalVaryingStringDataTypeContext) Accept

func (s *NationalVaryingStringDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NationalVaryingStringDataTypeContext) BINARY

func (*NationalVaryingStringDataTypeContext) CHAR

func (*NationalVaryingStringDataTypeContext) CHARACTER

func (*NationalVaryingStringDataTypeContext) EnterRule

func (*NationalVaryingStringDataTypeContext) ExitRule

func (*NationalVaryingStringDataTypeContext) GetRuleContext

func (*NationalVaryingStringDataTypeContext) GetTypeName

func (*NationalVaryingStringDataTypeContext) LengthOneDimension

func (*NationalVaryingStringDataTypeContext) NATIONAL

func (*NationalVaryingStringDataTypeContext) SetTypeName

func (*NationalVaryingStringDataTypeContext) VARYING

type NaturalJoinContext

type NaturalJoinContext struct {
	JoinPartContext
}

func NewNaturalJoinContext

func NewNaturalJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NaturalJoinContext

func (*NaturalJoinContext) Accept

func (s *NaturalJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NaturalJoinContext) EnterRule

func (s *NaturalJoinContext) EnterRule(listener antlr.ParseTreeListener)

func (*NaturalJoinContext) ExitRule

func (s *NaturalJoinContext) ExitRule(listener antlr.ParseTreeListener)

func (*NaturalJoinContext) GetRuleContext

func (s *NaturalJoinContext) GetRuleContext() antlr.RuleContext

func (*NaturalJoinContext) JOIN

func (*NaturalJoinContext) LEFT

func (*NaturalJoinContext) NATURAL

func (s *NaturalJoinContext) NATURAL() antlr.TerminalNode

func (*NaturalJoinContext) OUTER

func (*NaturalJoinContext) RIGHT

func (*NaturalJoinContext) TableSourceItem

func (s *NaturalJoinContext) TableSourceItem() ITableSourceItemContext

type NegativeDecimalConstantContext

type NegativeDecimalConstantContext struct {
	ConstantContext
}

func NewNegativeDecimalConstantContext

func NewNegativeDecimalConstantContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NegativeDecimalConstantContext

func (*NegativeDecimalConstantContext) Accept

func (s *NegativeDecimalConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NegativeDecimalConstantContext) DecimalLiteral

func (*NegativeDecimalConstantContext) EnterRule

func (*NegativeDecimalConstantContext) ExitRule

func (*NegativeDecimalConstantContext) GetRuleContext

func (s *NegativeDecimalConstantContext) GetRuleContext() antlr.RuleContext

func (*NegativeDecimalConstantContext) MINUS

type NonAggregateFunctionCallContext

type NonAggregateFunctionCallContext struct {
	FunctionCallContext
}

func NewNonAggregateFunctionCallContext

func NewNonAggregateFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NonAggregateFunctionCallContext

func (*NonAggregateFunctionCallContext) Accept

func (s *NonAggregateFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NonAggregateFunctionCallContext) EnterRule

func (*NonAggregateFunctionCallContext) ExitRule

func (*NonAggregateFunctionCallContext) GetRuleContext

func (*NonAggregateFunctionCallContext) NonAggregateWindowedFunction

type NonAggregateWindowedFunctionContext

type NonAggregateWindowedFunctionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNonAggregateWindowedFunctionContext

func NewEmptyNonAggregateWindowedFunctionContext() *NonAggregateWindowedFunctionContext

func NewNonAggregateWindowedFunctionContext

func NewNonAggregateWindowedFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NonAggregateWindowedFunctionContext

func (*NonAggregateWindowedFunctionContext) Accept

func (s *NonAggregateWindowedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NonAggregateWindowedFunctionContext) AllCOMMA

func (*NonAggregateWindowedFunctionContext) AllDecimalLiteral

func (*NonAggregateWindowedFunctionContext) COMMA

func (*NonAggregateWindowedFunctionContext) CUME_DIST

func (*NonAggregateWindowedFunctionContext) DENSE_RANK

func (*NonAggregateWindowedFunctionContext) DecimalLiteral

func (*NonAggregateWindowedFunctionContext) EnterRule

func (*NonAggregateWindowedFunctionContext) ExitRule

func (*NonAggregateWindowedFunctionContext) Expression

func (*NonAggregateWindowedFunctionContext) FIRST_VALUE

func (*NonAggregateWindowedFunctionContext) GetFunctionName

func (s *NonAggregateWindowedFunctionContext) GetFunctionName() antlr.Token

func (*NonAggregateWindowedFunctionContext) GetParser

func (*NonAggregateWindowedFunctionContext) GetRuleContext

func (*NonAggregateWindowedFunctionContext) IsNonAggregateWindowedFunctionContext

func (*NonAggregateWindowedFunctionContext) IsNonAggregateWindowedFunctionContext()

func (*NonAggregateWindowedFunctionContext) LAG

func (*NonAggregateWindowedFunctionContext) LAST_VALUE

func (*NonAggregateWindowedFunctionContext) LEAD

func (*NonAggregateWindowedFunctionContext) LEFT_ROUND_BRACKET

func (s *NonAggregateWindowedFunctionContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*NonAggregateWindowedFunctionContext) NTH_VALUE

func (*NonAggregateWindowedFunctionContext) NTILE

func (*NonAggregateWindowedFunctionContext) OverClause

func (*NonAggregateWindowedFunctionContext) PERCENT_RANK

func (*NonAggregateWindowedFunctionContext) RANK

func (*NonAggregateWindowedFunctionContext) RIGHT_ROUND_BRACKET

func (s *NonAggregateWindowedFunctionContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*NonAggregateWindowedFunctionContext) ROW_NUMBER

func (*NonAggregateWindowedFunctionContext) SetFunctionName

func (s *NonAggregateWindowedFunctionContext) SetFunctionName(v antlr.Token)

func (*NonAggregateWindowedFunctionContext) ToStringTree

func (s *NonAggregateWindowedFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NotExpressionContext

type NotExpressionContext struct {
	ExpressionContext
	// contains filtered or unexported fields
}

func NewNotExpressionContext

func NewNotExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotExpressionContext

func (*NotExpressionContext) Accept

func (s *NotExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NotExpressionContext) EXCLAMATION_SYMBOL

func (s *NotExpressionContext) EXCLAMATION_SYMBOL() antlr.TerminalNode

func (*NotExpressionContext) EnterRule

func (s *NotExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*NotExpressionContext) ExitRule

func (s *NotExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*NotExpressionContext) Expression

func (s *NotExpressionContext) Expression() IExpressionContext

func (*NotExpressionContext) GetNotOperator

func (s *NotExpressionContext) GetNotOperator() antlr.Token

func (*NotExpressionContext) GetRuleContext

func (s *NotExpressionContext) GetRuleContext() antlr.RuleContext

func (*NotExpressionContext) NOT

func (*NotExpressionContext) SetNotOperator

func (s *NotExpressionContext) SetNotOperator(v antlr.Token)

type NullCallClauseContext

type NullCallClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNullCallClauseContext

func NewEmptyNullCallClauseContext() *NullCallClauseContext

func NewNullCallClauseContext

func NewNullCallClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NullCallClauseContext

func (*NullCallClauseContext) Accept

func (s *NullCallClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NullCallClauseContext) AllNULL_LITERAL

func (s *NullCallClauseContext) AllNULL_LITERAL() []antlr.TerminalNode

func (*NullCallClauseContext) CALLED

func (*NullCallClauseContext) EnterRule

func (s *NullCallClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*NullCallClauseContext) ExitRule

func (s *NullCallClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*NullCallClauseContext) GetParser

func (s *NullCallClauseContext) GetParser() antlr.Parser

func (*NullCallClauseContext) GetRuleContext

func (s *NullCallClauseContext) GetRuleContext() antlr.RuleContext

func (*NullCallClauseContext) INPUT

func (*NullCallClauseContext) IsNullCallClauseContext

func (*NullCallClauseContext) IsNullCallClauseContext()

func (*NullCallClauseContext) NULL_LITERAL

func (s *NullCallClauseContext) NULL_LITERAL(i int) antlr.TerminalNode

func (*NullCallClauseContext) ON

func (*NullCallClauseContext) RETURNS

func (*NullCallClauseContext) ToStringTree

func (s *NullCallClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NullColumnConstraintContext

type NullColumnConstraintContext struct {
	ColumnConstraintContext
}

func NewNullColumnConstraintContext

func NewNullColumnConstraintContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NullColumnConstraintContext

func (*NullColumnConstraintContext) Accept

func (s *NullColumnConstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NullColumnConstraintContext) EnterRule

func (s *NullColumnConstraintContext) EnterRule(listener antlr.ParseTreeListener)

func (*NullColumnConstraintContext) ExitRule

func (s *NullColumnConstraintContext) ExitRule(listener antlr.ParseTreeListener)

func (*NullColumnConstraintContext) GetRuleContext

func (s *NullColumnConstraintContext) GetRuleContext() antlr.RuleContext

func (*NullColumnConstraintContext) NullNotnull

type NullConstantContext

type NullConstantContext struct {
	ConstantContext
}

func NewNullConstantContext

func NewNullConstantContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NullConstantContext

func (*NullConstantContext) Accept

func (s *NullConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NullConstantContext) EnterRule

func (s *NullConstantContext) EnterRule(listener antlr.ParseTreeListener)

func (*NullConstantContext) ExitRule

func (s *NullConstantContext) ExitRule(listener antlr.ParseTreeListener)

func (*NullConstantContext) GetRuleContext

func (s *NullConstantContext) GetRuleContext() antlr.RuleContext

func (*NullConstantContext) NOT

func (*NullConstantContext) NullLiteral

func (s *NullConstantContext) NullLiteral() INullLiteralContext

type NullLiteralContext

type NullLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNullLiteralContext

func NewEmptyNullLiteralContext() *NullLiteralContext

func NewNullLiteralContext

func NewNullLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NullLiteralContext

func (*NullLiteralContext) Accept

func (s *NullLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NullLiteralContext) EnterRule

func (s *NullLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*NullLiteralContext) ExitRule

func (s *NullLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*NullLiteralContext) GetParser

func (s *NullLiteralContext) GetParser() antlr.Parser

func (*NullLiteralContext) GetRuleContext

func (s *NullLiteralContext) GetRuleContext() antlr.RuleContext

func (*NullLiteralContext) IsNullLiteralContext

func (*NullLiteralContext) IsNullLiteralContext()

func (*NullLiteralContext) NULL_LITERAL

func (s *NullLiteralContext) NULL_LITERAL() antlr.TerminalNode

func (*NullLiteralContext) ToStringTree

func (s *NullLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NullNotnullContext

type NullNotnullContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNullNotnullContext

func NewEmptyNullNotnullContext() *NullNotnullContext

func NewNullNotnullContext

func NewNullNotnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NullNotnullContext

func (*NullNotnullContext) Accept

func (s *NullNotnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NullNotnullContext) EnterRule

func (s *NullNotnullContext) EnterRule(listener antlr.ParseTreeListener)

func (*NullNotnullContext) ExitRule

func (s *NullNotnullContext) ExitRule(listener antlr.ParseTreeListener)

func (*NullNotnullContext) GetParser

func (s *NullNotnullContext) GetParser() antlr.Parser

func (*NullNotnullContext) GetRuleContext

func (s *NullNotnullContext) GetRuleContext() antlr.RuleContext

func (*NullNotnullContext) IsNullNotnullContext

func (*NullNotnullContext) IsNullNotnullContext()

func (*NullNotnullContext) NOT

func (*NullNotnullContext) NULL_LITERAL

func (s *NullNotnullContext) NULL_LITERAL() antlr.TerminalNode

func (*NullNotnullContext) ToStringTree

func (s *NullNotnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NullTreatmentClauseContext

type NullTreatmentClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNullTreatmentClauseContext

func NewEmptyNullTreatmentClauseContext() *NullTreatmentClauseContext

func NewNullTreatmentClauseContext

func NewNullTreatmentClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NullTreatmentClauseContext

func (*NullTreatmentClauseContext) Accept

func (s *NullTreatmentClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NullTreatmentClauseContext) EnterRule

func (s *NullTreatmentClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*NullTreatmentClauseContext) ExitRule

func (s *NullTreatmentClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*NullTreatmentClauseContext) GetNullTreatment

func (s *NullTreatmentClauseContext) GetNullTreatment() antlr.Token

func (*NullTreatmentClauseContext) GetParser

func (s *NullTreatmentClauseContext) GetParser() antlr.Parser

func (*NullTreatmentClauseContext) GetRuleContext

func (s *NullTreatmentClauseContext) GetRuleContext() antlr.RuleContext

func (*NullTreatmentClauseContext) IGNORE

func (*NullTreatmentClauseContext) IsNullTreatmentClauseContext

func (*NullTreatmentClauseContext) IsNullTreatmentClauseContext()

func (*NullTreatmentClauseContext) NULLS

func (*NullTreatmentClauseContext) RESPECT

func (*NullTreatmentClauseContext) SetNullTreatment

func (s *NullTreatmentClauseContext) SetNullTreatment(v antlr.Token)

func (*NullTreatmentClauseContext) ToStringTree

func (s *NullTreatmentClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type OfTypeClauseContext

type OfTypeClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOfTypeClauseContext

func NewEmptyOfTypeClauseContext() *OfTypeClauseContext

func NewOfTypeClauseContext

func NewOfTypeClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OfTypeClauseContext

func (*OfTypeClauseContext) Accept

func (s *OfTypeClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OfTypeClauseContext) EnterRule

func (s *OfTypeClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*OfTypeClauseContext) ExitRule

func (s *OfTypeClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*OfTypeClauseContext) GetParser

func (s *OfTypeClauseContext) GetParser() antlr.Parser

func (*OfTypeClauseContext) GetRuleContext

func (s *OfTypeClauseContext) GetRuleContext() antlr.RuleContext

func (*OfTypeClauseContext) IsOfTypeClauseContext

func (*OfTypeClauseContext) IsOfTypeClauseContext()

func (*OfTypeClauseContext) STRUCT

func (*OfTypeClauseContext) ToStringTree

func (s *OfTypeClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*OfTypeClauseContext) Uid

type OptionContext

type OptionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOptionContext

func NewEmptyOptionContext() *OptionContext

func NewOptionContext

func NewOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionContext

func (*OptionContext) Accept

func (s *OptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OptionContext) BooleanLiteral

func (s *OptionContext) BooleanLiteral() IBooleanLiteralContext

func (*OptionContext) ENABLE_LONG_ROWS

func (s *OptionContext) ENABLE_LONG_ROWS() antlr.TerminalNode

func (*OptionContext) EQUAL_SYMBOL

func (s *OptionContext) EQUAL_SYMBOL() antlr.TerminalNode

func (*OptionContext) EnterRule

func (s *OptionContext) EnterRule(listener antlr.ParseTreeListener)

func (*OptionContext) ExitRule

func (s *OptionContext) ExitRule(listener antlr.ParseTreeListener)

func (*OptionContext) GetParser

func (s *OptionContext) GetParser() antlr.Parser

func (*OptionContext) GetRuleContext

func (s *OptionContext) GetRuleContext() antlr.RuleContext

func (*OptionContext) INTERMINGLE_TABLES

func (s *OptionContext) INTERMINGLE_TABLES() antlr.TerminalNode

func (*OptionContext) IsOptionContext

func (*OptionContext) IsOptionContext()

func (*OptionContext) STORE_ROW_VERSIONS

func (s *OptionContext) STORE_ROW_VERSIONS() antlr.TerminalNode

func (*OptionContext) ToStringTree

func (s *OptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type OptionsClauseContext

type OptionsClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOptionsClauseContext

func NewEmptyOptionsClauseContext() *OptionsClauseContext

func NewOptionsClauseContext

func NewOptionsClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptionsClauseContext

func (*OptionsClauseContext) Accept

func (s *OptionsClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OptionsClauseContext) AllCOMMA

func (s *OptionsClauseContext) AllCOMMA() []antlr.TerminalNode

func (*OptionsClauseContext) AllOption

func (s *OptionsClauseContext) AllOption() []IOptionContext

func (*OptionsClauseContext) COMMA

func (*OptionsClauseContext) EnterRule

func (s *OptionsClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*OptionsClauseContext) ExitRule

func (s *OptionsClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*OptionsClauseContext) GetParser

func (s *OptionsClauseContext) GetParser() antlr.Parser

func (*OptionsClauseContext) GetRuleContext

func (s *OptionsClauseContext) GetRuleContext() antlr.RuleContext

func (*OptionsClauseContext) IsOptionsClauseContext

func (*OptionsClauseContext) IsOptionsClauseContext()

func (*OptionsClauseContext) LEFT_ROUND_BRACKET

func (s *OptionsClauseContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*OptionsClauseContext) OPTIONS

func (*OptionsClauseContext) Option

func (*OptionsClauseContext) RIGHT_ROUND_BRACKET

func (s *OptionsClauseContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*OptionsClauseContext) ToStringTree

func (s *OptionsClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*OptionsClauseContext) WITH

type OrderByClauseContext

type OrderByClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOrderByClauseContext

func NewEmptyOrderByClauseContext() *OrderByClauseContext

func NewOrderByClauseContext

func NewOrderByClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderByClauseContext

func (*OrderByClauseContext) Accept

func (s *OrderByClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OrderByClauseContext) AllCOMMA

func (s *OrderByClauseContext) AllCOMMA() []antlr.TerminalNode

func (*OrderByClauseContext) AllOrderByExpression

func (s *OrderByClauseContext) AllOrderByExpression() []IOrderByExpressionContext

func (*OrderByClauseContext) BY

func (*OrderByClauseContext) COMMA

func (*OrderByClauseContext) EnterRule

func (s *OrderByClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*OrderByClauseContext) ExitRule

func (s *OrderByClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*OrderByClauseContext) GetParser

func (s *OrderByClauseContext) GetParser() antlr.Parser

func (*OrderByClauseContext) GetRuleContext

func (s *OrderByClauseContext) GetRuleContext() antlr.RuleContext

func (*OrderByClauseContext) IsOrderByClauseContext

func (*OrderByClauseContext) IsOrderByClauseContext()

func (*OrderByClauseContext) ORDER

func (*OrderByClauseContext) OrderByExpression

func (s *OrderByClauseContext) OrderByExpression(i int) IOrderByExpressionContext

func (*OrderByClauseContext) ToStringTree

func (s *OrderByClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type OrderByExpressionContext

type OrderByExpressionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOrderByExpressionContext

func NewEmptyOrderByExpressionContext() *OrderByExpressionContext

func NewOrderByExpressionContext

func NewOrderByExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderByExpressionContext

func (*OrderByExpressionContext) Accept

func (s *OrderByExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OrderByExpressionContext) EnterRule

func (s *OrderByExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*OrderByExpressionContext) ExitRule

func (s *OrderByExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*OrderByExpressionContext) Expression

func (*OrderByExpressionContext) GetParser

func (s *OrderByExpressionContext) GetParser() antlr.Parser

func (*OrderByExpressionContext) GetRuleContext

func (s *OrderByExpressionContext) GetRuleContext() antlr.RuleContext

func (*OrderByExpressionContext) IsOrderByExpressionContext

func (*OrderByExpressionContext) IsOrderByExpressionContext()

func (*OrderByExpressionContext) OrderClause

func (*OrderByExpressionContext) ToStringTree

func (s *OrderByExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type OrderClauseContext

type OrderClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOrderClauseContext

func NewEmptyOrderClauseContext() *OrderClauseContext

func NewOrderClauseContext

func NewOrderClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OrderClauseContext

func (*OrderClauseContext) ASC

func (*OrderClauseContext) Accept

func (s *OrderClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OrderClauseContext) DESC

func (*OrderClauseContext) EnterRule

func (s *OrderClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*OrderClauseContext) ExitRule

func (s *OrderClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*OrderClauseContext) FIRST

func (*OrderClauseContext) GetNulls

func (s *OrderClauseContext) GetNulls() antlr.Token

func (*OrderClauseContext) GetOrder

func (s *OrderClauseContext) GetOrder() antlr.Token

func (*OrderClauseContext) GetParser

func (s *OrderClauseContext) GetParser() antlr.Parser

func (*OrderClauseContext) GetRuleContext

func (s *OrderClauseContext) GetRuleContext() antlr.RuleContext

func (*OrderClauseContext) IsOrderClauseContext

func (*OrderClauseContext) IsOrderClauseContext()

func (*OrderClauseContext) LAST

func (*OrderClauseContext) NULLS

func (*OrderClauseContext) SetNulls

func (s *OrderClauseContext) SetNulls(v antlr.Token)

func (*OrderClauseContext) SetOrder

func (s *OrderClauseContext) SetOrder(v antlr.Token)

func (*OrderClauseContext) ToStringTree

func (s *OrderClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type OuterJoinContext

type OuterJoinContext struct {
	JoinPartContext
}

func NewOuterJoinContext

func NewOuterJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OuterJoinContext

func (*OuterJoinContext) Accept

func (s *OuterJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OuterJoinContext) EnterRule

func (s *OuterJoinContext) EnterRule(listener antlr.ParseTreeListener)

func (*OuterJoinContext) ExitRule

func (s *OuterJoinContext) ExitRule(listener antlr.ParseTreeListener)

func (*OuterJoinContext) Expression

func (s *OuterJoinContext) Expression() IExpressionContext

func (*OuterJoinContext) FULL

func (*OuterJoinContext) GetRuleContext

func (s *OuterJoinContext) GetRuleContext() antlr.RuleContext

func (*OuterJoinContext) JOIN

func (*OuterJoinContext) LEFT

func (*OuterJoinContext) LEFT_ROUND_BRACKET

func (s *OuterJoinContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*OuterJoinContext) ON

func (*OuterJoinContext) OUTER

func (s *OuterJoinContext) OUTER() antlr.TerminalNode

func (*OuterJoinContext) RIGHT

func (s *OuterJoinContext) RIGHT() antlr.TerminalNode

func (*OuterJoinContext) RIGHT_ROUND_BRACKET

func (s *OuterJoinContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*OuterJoinContext) TableSourceItem

func (s *OuterJoinContext) TableSourceItem() ITableSourceItemContext

func (*OuterJoinContext) USING

func (s *OuterJoinContext) USING() antlr.TerminalNode

func (*OuterJoinContext) UidList

func (s *OuterJoinContext) UidList() IUidListContext

type OverClauseContext

type OverClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOverClauseContext

func NewEmptyOverClauseContext() *OverClauseContext

func NewOverClauseContext

func NewOverClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OverClauseContext

func (*OverClauseContext) Accept

func (s *OverClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*OverClauseContext) EnterRule

func (s *OverClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*OverClauseContext) ExitRule

func (s *OverClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*OverClauseContext) GetParser

func (s *OverClauseContext) GetParser() antlr.Parser

func (*OverClauseContext) GetRuleContext

func (s *OverClauseContext) GetRuleContext() antlr.RuleContext

func (*OverClauseContext) IsOverClauseContext

func (*OverClauseContext) IsOverClauseContext()

func (*OverClauseContext) LEFT_ROUND_BRACKET

func (s *OverClauseContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*OverClauseContext) OVER

func (*OverClauseContext) RIGHT_ROUND_BRACKET

func (s *OverClauseContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*OverClauseContext) ToStringTree

func (s *OverClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*OverClauseContext) WindowName

func (s *OverClauseContext) WindowName() IWindowNameContext

func (*OverClauseContext) WindowSpec

func (s *OverClauseContext) WindowSpec() IWindowSpecContext

type ParameterModeContext

type ParameterModeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyParameterModeContext

func NewEmptyParameterModeContext() *ParameterModeContext

func NewParameterModeContext

func NewParameterModeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterModeContext

func (*ParameterModeContext) Accept

func (s *ParameterModeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ParameterModeContext) EnterRule

func (s *ParameterModeContext) EnterRule(listener antlr.ParseTreeListener)

func (*ParameterModeContext) ExitRule

func (s *ParameterModeContext) ExitRule(listener antlr.ParseTreeListener)

func (*ParameterModeContext) GetParser

func (s *ParameterModeContext) GetParser() antlr.Parser

func (*ParameterModeContext) GetRuleContext

func (s *ParameterModeContext) GetRuleContext() antlr.RuleContext

func (*ParameterModeContext) IN

func (*ParameterModeContext) INOUT

func (*ParameterModeContext) IsParameterModeContext

func (*ParameterModeContext) IsParameterModeContext()

func (*ParameterModeContext) OUT

func (*ParameterModeContext) ToStringTree

func (s *ParameterModeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ParameterStyleContext

type ParameterStyleContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyParameterStyleContext

func NewEmptyParameterStyleContext() *ParameterStyleContext

func NewParameterStyleContext

func NewParameterStyleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterStyleContext

func (*ParameterStyleContext) Accept

func (s *ParameterStyleContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ParameterStyleContext) EnterRule

func (s *ParameterStyleContext) EnterRule(listener antlr.ParseTreeListener)

func (*ParameterStyleContext) ExitRule

func (s *ParameterStyleContext) ExitRule(listener antlr.ParseTreeListener)

func (*ParameterStyleContext) GENERAL

func (*ParameterStyleContext) GetParser

func (s *ParameterStyleContext) GetParser() antlr.Parser

func (*ParameterStyleContext) GetRuleContext

func (s *ParameterStyleContext) GetRuleContext() antlr.RuleContext

func (*ParameterStyleContext) IsParameterStyleContext

func (*ParameterStyleContext) IsParameterStyleContext()

func (*ParameterStyleContext) PARAMETER

func (s *ParameterStyleContext) PARAMETER() antlr.TerminalNode

func (*ParameterStyleContext) SQL

func (*ParameterStyleContext) STYLE

func (*ParameterStyleContext) ToStringTree

func (s *ParameterStyleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ParenthesisQueryContext

type ParenthesisQueryContext struct {
	QueryTermContext
}

func NewParenthesisQueryContext

func NewParenthesisQueryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ParenthesisQueryContext

func (*ParenthesisQueryContext) Accept

func (s *ParenthesisQueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ParenthesisQueryContext) EnterRule

func (s *ParenthesisQueryContext) EnterRule(listener antlr.ParseTreeListener)

func (*ParenthesisQueryContext) ExitRule

func (s *ParenthesisQueryContext) ExitRule(listener antlr.ParseTreeListener)

func (*ParenthesisQueryContext) GetRuleContext

func (s *ParenthesisQueryContext) GetRuleContext() antlr.RuleContext

func (*ParenthesisQueryContext) LEFT_ROUND_BRACKET

func (s *ParenthesisQueryContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*ParenthesisQueryContext) Query

func (*ParenthesisQueryContext) RIGHT_ROUND_BRACKET

func (s *ParenthesisQueryContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

type PartitionClauseContext

type PartitionClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPartitionClauseContext

func NewEmptyPartitionClauseContext() *PartitionClauseContext

func NewPartitionClauseContext

func NewPartitionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionClauseContext

func (*PartitionClauseContext) Accept

func (s *PartitionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PartitionClauseContext) AllCOMMA

func (s *PartitionClauseContext) AllCOMMA() []antlr.TerminalNode

func (*PartitionClauseContext) AllFullId

func (s *PartitionClauseContext) AllFullId() []IFullIdContext

func (*PartitionClauseContext) BY

func (*PartitionClauseContext) COMMA

func (*PartitionClauseContext) EnterRule

func (s *PartitionClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*PartitionClauseContext) ExitRule

func (s *PartitionClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*PartitionClauseContext) FullId

func (*PartitionClauseContext) GetParser

func (s *PartitionClauseContext) GetParser() antlr.Parser

func (*PartitionClauseContext) GetRuleContext

func (s *PartitionClauseContext) GetRuleContext() antlr.RuleContext

func (*PartitionClauseContext) IsPartitionClauseContext

func (*PartitionClauseContext) IsPartitionClauseContext()

func (*PartitionClauseContext) PARTITION

func (s *PartitionClauseContext) PARTITION() antlr.TerminalNode

func (*PartitionClauseContext) ToStringTree

func (s *PartitionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type PathContext

type PathContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPathContext

func NewEmptyPathContext() *PathContext

func NewPathContext

func NewPathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PathContext

func (*PathContext) Accept

func (s *PathContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PathContext) EnterRule

func (s *PathContext) EnterRule(listener antlr.ParseTreeListener)

func (*PathContext) ExitRule

func (s *PathContext) ExitRule(listener antlr.ParseTreeListener)

func (*PathContext) GetParser

func (s *PathContext) GetParser() antlr.Parser

func (*PathContext) GetRuleContext

func (s *PathContext) GetRuleContext() antlr.RuleContext

func (*PathContext) IsPathContext

func (*PathContext) IsPathContext()

func (*PathContext) ToStringTree

func (s *PathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*PathContext) Uid

func (s *PathContext) Uid() IUidContext

type PositionFunctionCallContext

type PositionFunctionCallContext struct {
	SpecificFunctionContext
	// contains filtered or unexported fields
}

func NewPositionFunctionCallContext

func NewPositionFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PositionFunctionCallContext

func (*PositionFunctionCallContext) Accept

func (s *PositionFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PositionFunctionCallContext) AllExpression

func (s *PositionFunctionCallContext) AllExpression() []IExpressionContext

func (*PositionFunctionCallContext) AllStringLiteral

func (s *PositionFunctionCallContext) AllStringLiteral() []IStringLiteralContext

func (*PositionFunctionCallContext) EnterRule

func (s *PositionFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*PositionFunctionCallContext) ExitRule

func (s *PositionFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*PositionFunctionCallContext) Expression

func (*PositionFunctionCallContext) GetInExpression

func (s *PositionFunctionCallContext) GetInExpression() IExpressionContext

func (*PositionFunctionCallContext) GetInString

func (*PositionFunctionCallContext) GetPositionExpression

func (s *PositionFunctionCallContext) GetPositionExpression() IExpressionContext

func (*PositionFunctionCallContext) GetPositionString

func (s *PositionFunctionCallContext) GetPositionString() IStringLiteralContext

func (*PositionFunctionCallContext) GetRuleContext

func (s *PositionFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*PositionFunctionCallContext) IN

func (*PositionFunctionCallContext) LEFT_ROUND_BRACKET

func (s *PositionFunctionCallContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*PositionFunctionCallContext) POSITION

func (*PositionFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *PositionFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*PositionFunctionCallContext) SetInExpression

func (s *PositionFunctionCallContext) SetInExpression(v IExpressionContext)

func (*PositionFunctionCallContext) SetInString

func (*PositionFunctionCallContext) SetPositionExpression

func (s *PositionFunctionCallContext) SetPositionExpression(v IExpressionContext)

func (*PositionFunctionCallContext) SetPositionString

func (s *PositionFunctionCallContext) SetPositionString(v IStringLiteralContext)

func (*PositionFunctionCallContext) StringLiteral

type PredicateContext

type PredicateContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPredicateContext

func NewEmptyPredicateContext() *PredicateContext

func NewPredicateContext

func NewPredicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PredicateContext

func (*PredicateContext) CopyAll

func (s *PredicateContext) CopyAll(ctx *PredicateContext)

func (*PredicateContext) GetParser

func (s *PredicateContext) GetParser() antlr.Parser

func (*PredicateContext) GetRuleContext

func (s *PredicateContext) GetRuleContext() antlr.RuleContext

func (*PredicateContext) IsPredicateContext

func (*PredicateContext) IsPredicateContext()

func (*PredicateContext) ToStringTree

func (s *PredicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type PredicatedExpressionContext

type PredicatedExpressionContext struct {
	ExpressionContext
}

func NewPredicatedExpressionContext

func NewPredicatedExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *PredicatedExpressionContext

func (*PredicatedExpressionContext) Accept

func (s *PredicatedExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PredicatedExpressionContext) EnterRule

func (s *PredicatedExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*PredicatedExpressionContext) ExitRule

func (s *PredicatedExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*PredicatedExpressionContext) ExpressionAtom

func (*PredicatedExpressionContext) GetRuleContext

func (s *PredicatedExpressionContext) GetRuleContext() antlr.RuleContext

func (*PredicatedExpressionContext) Predicate

type PrepareStatementContext

type PrepareStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPrepareStatementContext

func NewEmptyPrepareStatementContext() *PrepareStatementContext

func NewPrepareStatementContext

func NewPrepareStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrepareStatementContext

func (*PrepareStatementContext) Accept

func (s *PrepareStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PrepareStatementContext) EnterRule

func (s *PrepareStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*PrepareStatementContext) ExitRule

func (s *PrepareStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*PrepareStatementContext) FROM

func (*PrepareStatementContext) GetParser

func (s *PrepareStatementContext) GetParser() antlr.Parser

func (*PrepareStatementContext) GetQueryString

func (s *PrepareStatementContext) GetQueryString() antlr.Token

func (*PrepareStatementContext) GetRuleContext

func (s *PrepareStatementContext) GetRuleContext() antlr.RuleContext

func (*PrepareStatementContext) GetVariable

func (s *PrepareStatementContext) GetVariable() antlr.Token

func (*PrepareStatementContext) IsPrepareStatementContext

func (*PrepareStatementContext) IsPrepareStatementContext()

func (*PrepareStatementContext) LOCAL_ID

func (*PrepareStatementContext) PREPARE

func (*PrepareStatementContext) STRING_LITERAL

func (s *PrepareStatementContext) STRING_LITERAL() antlr.TerminalNode

func (*PrepareStatementContext) SetQueryString

func (s *PrepareStatementContext) SetQueryString(v antlr.Token)

func (*PrepareStatementContext) SetVariable

func (s *PrepareStatementContext) SetVariable(v antlr.Token)

func (*PrepareStatementContext) ToStringTree

func (s *PrepareStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*PrepareStatementContext) Uid

type PreparedStatementContext

type PreparedStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPreparedStatementContext

func NewEmptyPreparedStatementContext() *PreparedStatementContext

func NewPreparedStatementContext

func NewPreparedStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreparedStatementContext

func (*PreparedStatementContext) Accept

func (s *PreparedStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PreparedStatementContext) EnterRule

func (s *PreparedStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*PreparedStatementContext) ExecuteStatement

func (s *PreparedStatementContext) ExecuteStatement() IExecuteStatementContext

func (*PreparedStatementContext) ExitRule

func (s *PreparedStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*PreparedStatementContext) GetParser

func (s *PreparedStatementContext) GetParser() antlr.Parser

func (*PreparedStatementContext) GetRuleContext

func (s *PreparedStatementContext) GetRuleContext() antlr.RuleContext

func (*PreparedStatementContext) IsPreparedStatementContext

func (*PreparedStatementContext) IsPreparedStatementContext()

func (*PreparedStatementContext) PrepareStatement

func (s *PreparedStatementContext) PrepareStatement() IPrepareStatementContext

func (*PreparedStatementContext) ToStringTree

func (s *PreparedStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type PreparedStatementParameterAtomContext

type PreparedStatementParameterAtomContext struct {
	ExpressionAtomContext
}

func (*PreparedStatementParameterAtomContext) Accept

func (s *PreparedStatementParameterAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PreparedStatementParameterAtomContext) EnterRule

func (*PreparedStatementParameterAtomContext) ExitRule

func (*PreparedStatementParameterAtomContext) GetRuleContext

func (*PreparedStatementParameterAtomContext) PreparedStatementParameter

type PreparedStatementParameterContext

type PreparedStatementParameterContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPreparedStatementParameterContext

func NewEmptyPreparedStatementParameterContext() *PreparedStatementParameterContext

func NewPreparedStatementParameterContext

func NewPreparedStatementParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreparedStatementParameterContext

func (*PreparedStatementParameterContext) Accept

func (s *PreparedStatementParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PreparedStatementParameterContext) EnterRule

func (*PreparedStatementParameterContext) ExitRule

func (*PreparedStatementParameterContext) GetParser

func (*PreparedStatementParameterContext) GetRuleContext

func (*PreparedStatementParameterContext) IsPreparedStatementParameterContext

func (*PreparedStatementParameterContext) IsPreparedStatementParameterContext()

func (*PreparedStatementParameterContext) NAMED_PARAMETER

func (*PreparedStatementParameterContext) QUESTION

func (*PreparedStatementParameterContext) ToStringTree

func (s *PreparedStatementParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type PrimaryKeyDefinitionContext

type PrimaryKeyDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPrimaryKeyDefinitionContext

func NewEmptyPrimaryKeyDefinitionContext() *PrimaryKeyDefinitionContext

func NewPrimaryKeyDefinitionContext

func NewPrimaryKeyDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimaryKeyDefinitionContext

func (*PrimaryKeyDefinitionContext) Accept

func (s *PrimaryKeyDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PrimaryKeyDefinitionContext) EnterRule

func (s *PrimaryKeyDefinitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*PrimaryKeyDefinitionContext) ExitRule

func (s *PrimaryKeyDefinitionContext) ExitRule(listener antlr.ParseTreeListener)

func (*PrimaryKeyDefinitionContext) FullIdList

func (*PrimaryKeyDefinitionContext) GetParser

func (s *PrimaryKeyDefinitionContext) GetParser() antlr.Parser

func (*PrimaryKeyDefinitionContext) GetRuleContext

func (s *PrimaryKeyDefinitionContext) GetRuleContext() antlr.RuleContext

func (*PrimaryKeyDefinitionContext) IsPrimaryKeyDefinitionContext

func (*PrimaryKeyDefinitionContext) IsPrimaryKeyDefinitionContext()

func (*PrimaryKeyDefinitionContext) KEY

func (*PrimaryKeyDefinitionContext) ONLY

func (*PrimaryKeyDefinitionContext) PRIMARY

func (*PrimaryKeyDefinitionContext) ROW

func (*PrimaryKeyDefinitionContext) SINGLE

func (*PrimaryKeyDefinitionContext) ToStringTree

func (s *PrimaryKeyDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type PrimitiveTypeContext

type PrimitiveTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPrimitiveTypeContext

func NewEmptyPrimitiveTypeContext() *PrimitiveTypeContext

func NewPrimitiveTypeContext

func NewPrimitiveTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrimitiveTypeContext

func (*PrimitiveTypeContext) Accept

func (s *PrimitiveTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PrimitiveTypeContext) BIGINT

func (*PrimitiveTypeContext) BOOLEAN

func (*PrimitiveTypeContext) BYTES

func (*PrimitiveTypeContext) DATE

func (*PrimitiveTypeContext) DOUBLE

func (*PrimitiveTypeContext) EnterRule

func (s *PrimitiveTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*PrimitiveTypeContext) ExitRule

func (s *PrimitiveTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*PrimitiveTypeContext) FLOAT

func (*PrimitiveTypeContext) GetParser

func (s *PrimitiveTypeContext) GetParser() antlr.Parser

func (*PrimitiveTypeContext) GetRuleContext

func (s *PrimitiveTypeContext) GetRuleContext() antlr.RuleContext

func (*PrimitiveTypeContext) INTEGER

func (*PrimitiveTypeContext) IsPrimitiveTypeContext

func (*PrimitiveTypeContext) IsPrimitiveTypeContext()

func (*PrimitiveTypeContext) STRING

func (*PrimitiveTypeContext) TIMESTAMP

func (s *PrimitiveTypeContext) TIMESTAMP() antlr.TerminalNode

func (*PrimitiveTypeContext) ToStringTree

func (s *PrimitiveTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*PrimitiveTypeContext) UUID

func (*PrimitiveTypeContext) VectorType

func (s *PrimitiveTypeContext) VectorType() IVectorTypeContext

type QualifyClauseContext

type QualifyClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQualifyClauseContext

func NewEmptyQualifyClauseContext() *QualifyClauseContext

func NewQualifyClauseContext

func NewQualifyClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QualifyClauseContext

func (*QualifyClauseContext) Accept

func (s *QualifyClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*QualifyClauseContext) EnterRule

func (s *QualifyClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*QualifyClauseContext) ExitRule

func (s *QualifyClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*QualifyClauseContext) Expression

func (s *QualifyClauseContext) Expression() IExpressionContext

func (*QualifyClauseContext) GetParser

func (s *QualifyClauseContext) GetParser() antlr.Parser

func (*QualifyClauseContext) GetRuleContext

func (s *QualifyClauseContext) GetRuleContext() antlr.RuleContext

func (*QualifyClauseContext) IsQualifyClauseContext

func (*QualifyClauseContext) IsQualifyClauseContext()

func (*QualifyClauseContext) QUALIFY

func (*QualifyClauseContext) ToStringTree

func (s *QualifyClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type QueryContext

type QueryContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQueryContext

func NewEmptyQueryContext() *QueryContext

func NewQueryContext

func NewQueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryContext

func (*QueryContext) Accept

func (s *QueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*QueryContext) Ctes

func (s *QueryContext) Ctes() ICtesContext

func (*QueryContext) EnterRule

func (s *QueryContext) EnterRule(listener antlr.ParseTreeListener)

func (*QueryContext) ExitRule

func (s *QueryContext) ExitRule(listener antlr.ParseTreeListener)

func (*QueryContext) GetParser

func (s *QueryContext) GetParser() antlr.Parser

func (*QueryContext) GetRuleContext

func (s *QueryContext) GetRuleContext() antlr.RuleContext

func (*QueryContext) IsQueryContext

func (*QueryContext) IsQueryContext()

func (*QueryContext) QueryExpressionBody

func (s *QueryContext) QueryExpressionBody() IQueryExpressionBodyContext

func (*QueryContext) ToStringTree

func (s *QueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type QueryExpressionBodyContext

type QueryExpressionBodyContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQueryExpressionBodyContext

func NewEmptyQueryExpressionBodyContext() *QueryExpressionBodyContext

func NewQueryExpressionBodyContext

func NewQueryExpressionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryExpressionBodyContext

func (*QueryExpressionBodyContext) CopyAll

func (*QueryExpressionBodyContext) GetParser

func (s *QueryExpressionBodyContext) GetParser() antlr.Parser

func (*QueryExpressionBodyContext) GetRuleContext

func (s *QueryExpressionBodyContext) GetRuleContext() antlr.RuleContext

func (*QueryExpressionBodyContext) IsQueryExpressionBodyContext

func (*QueryExpressionBodyContext) IsQueryExpressionBodyContext()

func (*QueryExpressionBodyContext) ToStringTree

func (s *QueryExpressionBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type QueryTermContext

type QueryTermContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQueryTermContext

func NewEmptyQueryTermContext() *QueryTermContext

func NewQueryTermContext

func NewQueryTermContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryTermContext

func (*QueryTermContext) CopyAll

func (s *QueryTermContext) CopyAll(ctx *QueryTermContext)

func (*QueryTermContext) GetParser

func (s *QueryTermContext) GetParser() antlr.Parser

func (*QueryTermContext) GetRuleContext

func (s *QueryTermContext) GetRuleContext() antlr.RuleContext

func (*QueryTermContext) IsQueryTermContext

func (*QueryTermContext) IsQueryTermContext()

func (*QueryTermContext) ToStringTree

func (s *QueryTermContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type QueryTermDefaultContext

type QueryTermDefaultContext struct {
	QueryExpressionBodyContext
}

func NewQueryTermDefaultContext

func NewQueryTermDefaultContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *QueryTermDefaultContext

func (*QueryTermDefaultContext) Accept

func (s *QueryTermDefaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*QueryTermDefaultContext) EnterRule

func (s *QueryTermDefaultContext) EnterRule(listener antlr.ParseTreeListener)

func (*QueryTermDefaultContext) ExitRule

func (s *QueryTermDefaultContext) ExitRule(listener antlr.ParseTreeListener)

func (*QueryTermDefaultContext) GetRuleContext

func (s *QueryTermDefaultContext) GetRuleContext() antlr.RuleContext

func (*QueryTermDefaultContext) QueryTerm

type RecordConstructorContext

type RecordConstructorContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRecordConstructorContext

func NewEmptyRecordConstructorContext() *RecordConstructorContext

func NewRecordConstructorContext

func NewRecordConstructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RecordConstructorContext

func (*RecordConstructorContext) Accept

func (s *RecordConstructorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*RecordConstructorContext) AllCOMMA

func (*RecordConstructorContext) AllExpressionWithOptionalName

func (s *RecordConstructorContext) AllExpressionWithOptionalName() []IExpressionWithOptionalNameContext

func (*RecordConstructorContext) COMMA

func (*RecordConstructorContext) DOT

func (*RecordConstructorContext) EnterRule

func (s *RecordConstructorContext) EnterRule(listener antlr.ParseTreeListener)

func (*RecordConstructorContext) ExitRule

func (s *RecordConstructorContext) ExitRule(listener antlr.ParseTreeListener)

func (*RecordConstructorContext) ExpressionWithOptionalName

func (s *RecordConstructorContext) ExpressionWithOptionalName(i int) IExpressionWithOptionalNameContext

func (*RecordConstructorContext) GetParser

func (s *RecordConstructorContext) GetParser() antlr.Parser

func (*RecordConstructorContext) GetRuleContext

func (s *RecordConstructorContext) GetRuleContext() antlr.RuleContext

func (*RecordConstructorContext) IsRecordConstructorContext

func (*RecordConstructorContext) IsRecordConstructorContext()

func (*RecordConstructorContext) LEFT_ROUND_BRACKET

func (s *RecordConstructorContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*RecordConstructorContext) OfTypeClause

func (*RecordConstructorContext) RIGHT_ROUND_BRACKET

func (s *RecordConstructorContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*RecordConstructorContext) STAR

func (*RecordConstructorContext) ToStringTree

func (s *RecordConstructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*RecordConstructorContext) Uid

type RecordConstructorExpressionAtomContext

type RecordConstructorExpressionAtomContext struct {
	ExpressionAtomContext
}

func (*RecordConstructorExpressionAtomContext) Accept

func (s *RecordConstructorExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*RecordConstructorExpressionAtomContext) EnterRule

func (*RecordConstructorExpressionAtomContext) ExitRule

func (*RecordConstructorExpressionAtomContext) GetRuleContext

func (*RecordConstructorExpressionAtomContext) RecordConstructor

type RecordConstructorForInlineTableContext

type RecordConstructorForInlineTableContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRecordConstructorForInlineTableContext

func NewEmptyRecordConstructorForInlineTableContext() *RecordConstructorForInlineTableContext

func NewRecordConstructorForInlineTableContext

func NewRecordConstructorForInlineTableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RecordConstructorForInlineTableContext

func (*RecordConstructorForInlineTableContext) Accept

func (s *RecordConstructorForInlineTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*RecordConstructorForInlineTableContext) AllCOMMA

func (*RecordConstructorForInlineTableContext) AllExpressionWithOptionalName

func (*RecordConstructorForInlineTableContext) COMMA

func (*RecordConstructorForInlineTableContext) EnterRule

func (*RecordConstructorForInlineTableContext) ExitRule

func (*RecordConstructorForInlineTableContext) ExpressionWithOptionalName

func (*RecordConstructorForInlineTableContext) GetParser

func (*RecordConstructorForInlineTableContext) GetRuleContext

func (*RecordConstructorForInlineTableContext) IsRecordConstructorForInlineTableContext

func (*RecordConstructorForInlineTableContext) IsRecordConstructorForInlineTableContext()

func (*RecordConstructorForInlineTableContext) LEFT_ROUND_BRACKET

func (*RecordConstructorForInlineTableContext) RIGHT_ROUND_BRACKET

func (*RecordConstructorForInlineTableContext) ToStringTree

func (s *RecordConstructorForInlineTableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type RecordConstructorForInsertContext

type RecordConstructorForInsertContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRecordConstructorForInsertContext

func NewEmptyRecordConstructorForInsertContext() *RecordConstructorForInsertContext

func NewRecordConstructorForInsertContext

func NewRecordConstructorForInsertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RecordConstructorForInsertContext

func (*RecordConstructorForInsertContext) Accept

func (s *RecordConstructorForInsertContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*RecordConstructorForInsertContext) AllCOMMA

func (*RecordConstructorForInsertContext) AllExpressionWithOptionalName

func (s *RecordConstructorForInsertContext) AllExpressionWithOptionalName() []IExpressionWithOptionalNameContext

func (*RecordConstructorForInsertContext) COMMA

func (*RecordConstructorForInsertContext) EnterRule

func (*RecordConstructorForInsertContext) ExitRule

func (*RecordConstructorForInsertContext) ExpressionWithOptionalName

func (*RecordConstructorForInsertContext) GetParser

func (*RecordConstructorForInsertContext) GetRuleContext

func (*RecordConstructorForInsertContext) IsRecordConstructorForInsertContext

func (*RecordConstructorForInsertContext) IsRecordConstructorForInsertContext()

func (*RecordConstructorForInsertContext) LEFT_ROUND_BRACKET

func (s *RecordConstructorForInsertContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*RecordConstructorForInsertContext) RIGHT_ROUND_BRACKET

func (s *RecordConstructorForInsertContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*RecordConstructorForInsertContext) ToStringTree

func (s *RecordConstructorForInsertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type RelationalLexer

type RelationalLexer struct {
	*antlr.BaseLexer
	// contains filtered or unexported fields
}

func NewRelationalLexer

func NewRelationalLexer(input antlr.CharStream) *RelationalLexer

NewRelationalLexer produces a new lexer instance for the optional input antlr.CharStream.

func (*RelationalLexer) NextToken

func (l *RelationalLexer) NextToken() antlr.Token

func (*RelationalLexer) PopMode

func (l *RelationalLexer) PopMode() int

func (*RelationalLexer) PushMode

func (l *RelationalLexer) PushMode(m int)

type RelationalParser

type RelationalParser struct {
	*antlr.BaseParser
}

func NewRelationalParser

func NewRelationalParser(input antlr.TokenStream) *RelationalParser

NewRelationalParser produces a new parser instance for the optional input antlr.TokenStream.

func (*RelationalParser) AdministrationStatement

func (p *RelationalParser) AdministrationStatement() (localctx IAdministrationStatementContext)

func (*RelationalParser) AggregateLimitClause

func (p *RelationalParser) AggregateLimitClause() (localctx IAggregateLimitClauseContext)

func (*RelationalParser) AggregateWindowedFunction

func (p *RelationalParser) AggregateWindowedFunction() (localctx IAggregateWindowedFunctionContext)

func (*RelationalParser) ArrayConstructor

func (p *RelationalParser) ArrayConstructor() (localctx IArrayConstructorContext)

func (*RelationalParser) AssignmentField

func (p *RelationalParser) AssignmentField() (localctx IAssignmentFieldContext)

func (*RelationalParser) BitOperator

func (p *RelationalParser) BitOperator() (localctx IBitOperatorContext)

func (*RelationalParser) BooleanLiteral

func (p *RelationalParser) BooleanLiteral() (localctx IBooleanLiteralContext)

func (*RelationalParser) BytesLiteral

func (p *RelationalParser) BytesLiteral() (localctx IBytesLiteralContext)

func (*RelationalParser) CaseFuncAlternative

func (p *RelationalParser) CaseFuncAlternative() (localctx ICaseFuncAlternativeContext)

func (*RelationalParser) CharSet

func (p *RelationalParser) CharSet() (localctx ICharSetContext)

func (*RelationalParser) CharsetName

func (p *RelationalParser) CharsetName() (localctx ICharsetNameContext)

func (*RelationalParser) CharsetNameBase

func (p *RelationalParser) CharsetNameBase() (localctx ICharsetNameBaseContext)

func (*RelationalParser) CollationName

func (p *RelationalParser) CollationName() (localctx ICollationNameContext)

func (*RelationalParser) CollectionOptions

func (p *RelationalParser) CollectionOptions() (localctx ICollectionOptionsContext)

func (*RelationalParser) ColumnConstraint

func (p *RelationalParser) ColumnConstraint() (localctx IColumnConstraintContext)

func (*RelationalParser) ColumnDefinition

func (p *RelationalParser) ColumnDefinition() (localctx IColumnDefinitionContext)

func (*RelationalParser) ColumnType

func (p *RelationalParser) ColumnType() (localctx IColumnTypeContext)

func (*RelationalParser) CommitStatement

func (p *RelationalParser) CommitStatement() (localctx ICommitStatementContext)

func (*RelationalParser) ComparisonOperator

func (p *RelationalParser) ComparisonOperator() (localctx IComparisonOperatorContext)

func (*RelationalParser) Constant

func (p *RelationalParser) Constant() (localctx IConstantContext)

func (*RelationalParser) ContinuationAtom

func (p *RelationalParser) ContinuationAtom() (localctx IContinuationAtomContext)

func (*RelationalParser) ConvertedDataType

func (p *RelationalParser) ConvertedDataType() (localctx IConvertedDataTypeContext)

func (*RelationalParser) CopyStatement

func (p *RelationalParser) CopyStatement() (localctx ICopyStatementContext)

func (*RelationalParser) CreateStatement

func (p *RelationalParser) CreateStatement() (localctx ICreateStatementContext)

func (*RelationalParser) CreateTempFunction

func (p *RelationalParser) CreateTempFunction() (localctx ICreateTempFunctionContext)

func (*RelationalParser) Ctes

func (p *RelationalParser) Ctes() (localctx ICtesContext)

func (*RelationalParser) CurrentTimestamp

func (p *RelationalParser) CurrentTimestamp() (localctx ICurrentTimestampContext)

func (*RelationalParser) DataType

func (p *RelationalParser) DataType() (localctx IDataTypeContext)

func (*RelationalParser) DdlStatement

func (p *RelationalParser) DdlStatement() (localctx IDdlStatementContext)

func (*RelationalParser) DecimalLiteral

func (p *RelationalParser) DecimalLiteral() (localctx IDecimalLiteralContext)

func (*RelationalParser) DeclareBlock

func (p *RelationalParser) DeclareBlock() (localctx IDeclareBlockContext)

func (*RelationalParser) DeclaredFunction

func (p *RelationalParser) DeclaredFunction() (localctx IDeclaredFunctionContext)

func (*RelationalParser) DefaultValue

func (p *RelationalParser) DefaultValue() (localctx IDefaultValueContext)

func (*RelationalParser) DeleteStatement

func (p *RelationalParser) DeleteStatement() (localctx IDeleteStatementContext)

func (*RelationalParser) DescribeObjectClause

func (p *RelationalParser) DescribeObjectClause() (localctx IDescribeObjectClauseContext)

func (*RelationalParser) DeterministicCharacteristic

func (p *RelationalParser) DeterministicCharacteristic() (localctx IDeterministicCharacteristicContext)

func (*RelationalParser) DispatchClause

func (p *RelationalParser) DispatchClause() (localctx IDispatchClauseContext)

func (*RelationalParser) DmlStatement

func (p *RelationalParser) DmlStatement() (localctx IDmlStatementContext)

func (*RelationalParser) DropStatement

func (p *RelationalParser) DropStatement() (localctx IDropStatementContext)

func (*RelationalParser) DropTempFunction

func (p *RelationalParser) DropTempFunction() (localctx IDropTempFunctionContext)

func (*RelationalParser) EnumDefinition

func (p *RelationalParser) EnumDefinition() (localctx IEnumDefinitionContext)

func (*RelationalParser) ExecuteContinuationStatement

func (p *RelationalParser) ExecuteContinuationStatement() (localctx IExecuteContinuationStatementContext)

func (*RelationalParser) ExecuteStatement

func (p *RelationalParser) ExecuteStatement() (localctx IExecuteStatementContext)

func (*RelationalParser) Expression

func (p *RelationalParser) Expression() (localctx IExpressionContext)

func (*RelationalParser) ExpressionAtom

func (p *RelationalParser) ExpressionAtom() (localctx IExpressionAtomContext)

func (*RelationalParser) ExpressionAtom_Sempred

func (p *RelationalParser) ExpressionAtom_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*RelationalParser) ExpressionOrDefault

func (p *RelationalParser) ExpressionOrDefault() (localctx IExpressionOrDefaultContext)

func (*RelationalParser) ExpressionWithOptionalName

func (p *RelationalParser) ExpressionWithOptionalName() (localctx IExpressionWithOptionalNameContext)

func (*RelationalParser) Expression_Sempred

func (p *RelationalParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*RelationalParser) Expressions

func (p *RelationalParser) Expressions() (localctx IExpressionsContext)

func (*RelationalParser) ExpressionsWithDefaults

func (p *RelationalParser) ExpressionsWithDefaults() (localctx IExpressionsWithDefaultsContext)

func (*RelationalParser) FromClause

func (p *RelationalParser) FromClause() (localctx IFromClauseContext)

func (*RelationalParser) FullColumnName

func (p *RelationalParser) FullColumnName() (localctx IFullColumnNameContext)

func (*RelationalParser) FullDescribeStatement

func (p *RelationalParser) FullDescribeStatement() (localctx IFullDescribeStatementContext)

func (*RelationalParser) FullId

func (p *RelationalParser) FullId() (localctx IFullIdContext)

func (*RelationalParser) FullIdList

func (p *RelationalParser) FullIdList() (localctx IFullIdListContext)

func (*RelationalParser) FunctionArg

func (p *RelationalParser) FunctionArg() (localctx IFunctionArgContext)

func (*RelationalParser) FunctionArgs

func (p *RelationalParser) FunctionArgs() (localctx IFunctionArgsContext)

func (*RelationalParser) FunctionCall

func (p *RelationalParser) FunctionCall() (localctx IFunctionCallContext)

func (*RelationalParser) FunctionColumnType

func (p *RelationalParser) FunctionColumnType() (localctx IFunctionColumnTypeContext)

func (*RelationalParser) FunctionNameBase

func (p *RelationalParser) FunctionNameBase() (localctx IFunctionNameBaseContext)

func (*RelationalParser) FunctionNameKeyword

func (p *RelationalParser) FunctionNameKeyword() (localctx IFunctionNameKeywordContext)

func (*RelationalParser) FunctionSpecification

func (p *RelationalParser) FunctionSpecification() (localctx IFunctionSpecificationContext)

func (*RelationalParser) GroupByClause

func (p *RelationalParser) GroupByClause() (localctx IGroupByClauseContext)

func (*RelationalParser) GroupByItem

func (p *RelationalParser) GroupByItem() (localctx IGroupByItemContext)

func (*RelationalParser) HavingClause

func (p *RelationalParser) HavingClause() (localctx IHavingClauseContext)

func (*RelationalParser) HelpStatement

func (p *RelationalParser) HelpStatement() (localctx IHelpStatementContext)

func (*RelationalParser) HnswMetric

func (p *RelationalParser) HnswMetric() (localctx IHnswMetricContext)

func (*RelationalParser) IfExists

func (p *RelationalParser) IfExists() (localctx IIfExistsContext)

func (*RelationalParser) IfNotExists

func (p *RelationalParser) IfNotExists() (localctx IIfNotExistsContext)

func (*RelationalParser) InList

func (p *RelationalParser) InList() (localctx IInListContext)

func (*RelationalParser) IncludeClause

func (p *RelationalParser) IncludeClause() (localctx IIncludeClauseContext)

func (*RelationalParser) IndexAttribute

func (p *RelationalParser) IndexAttribute() (localctx IIndexAttributeContext)

func (*RelationalParser) IndexAttributes

func (p *RelationalParser) IndexAttributes() (localctx IIndexAttributesContext)

func (*RelationalParser) IndexColumnList

func (p *RelationalParser) IndexColumnList() (localctx IIndexColumnListContext)

func (*RelationalParser) IndexColumnName

func (p *RelationalParser) IndexColumnName() (localctx IIndexColumnNameContext)

func (*RelationalParser) IndexColumnNames

func (p *RelationalParser) IndexColumnNames() (localctx IIndexColumnNamesContext)

func (*RelationalParser) IndexColumnSpec

func (p *RelationalParser) IndexColumnSpec() (localctx IIndexColumnSpecContext)

func (*RelationalParser) IndexDefinition

func (p *RelationalParser) IndexDefinition() (localctx IIndexDefinitionContext)

func (*RelationalParser) IndexHint

func (p *RelationalParser) IndexHint() (localctx IIndexHintContext)

func (*RelationalParser) IndexHintType

func (p *RelationalParser) IndexHintType() (localctx IIndexHintTypeContext)

func (*RelationalParser) IndexOption

func (p *RelationalParser) IndexOption() (localctx IIndexOptionContext)

func (*RelationalParser) IndexOptions

func (p *RelationalParser) IndexOptions() (localctx IIndexOptionsContext)

func (*RelationalParser) IndexPartitionClause

func (p *RelationalParser) IndexPartitionClause() (localctx IIndexPartitionClauseContext)

func (*RelationalParser) IndexType

func (p *RelationalParser) IndexType() (localctx IIndexTypeContext)

func (*RelationalParser) InlineTableDefinition

func (p *RelationalParser) InlineTableDefinition() (localctx IInlineTableDefinitionContext)

func (*RelationalParser) InsertStatement

func (p *RelationalParser) InsertStatement() (localctx IInsertStatementContext)

func (*RelationalParser) InsertStatementValue

func (p *RelationalParser) InsertStatementValue() (localctx IInsertStatementValueContext)

func (*RelationalParser) IntervalType

func (p *RelationalParser) IntervalType() (localctx IIntervalTypeContext)

func (*RelationalParser) IntervalTypeBase

func (p *RelationalParser) IntervalTypeBase() (localctx IIntervalTypeBaseContext)

func (*RelationalParser) JoinPart

func (p *RelationalParser) JoinPart() (localctx IJoinPartContext)

func (*RelationalParser) JsonOperator

func (p *RelationalParser) JsonOperator() (localctx IJsonOperatorContext)

func (*RelationalParser) KeywordsCanBeId

func (p *RelationalParser) KeywordsCanBeId() (localctx IKeywordsCanBeIdContext)

func (*RelationalParser) KillStatement

func (p *RelationalParser) KillStatement() (localctx IKillStatementContext)

func (*RelationalParser) LanguageClause

func (p *RelationalParser) LanguageClause() (localctx ILanguageClauseContext)

func (*RelationalParser) LanguageName

func (p *RelationalParser) LanguageName() (localctx ILanguageNameContext)

func (*RelationalParser) LengthOneDimension

func (p *RelationalParser) LengthOneDimension() (localctx ILengthOneDimensionContext)

func (*RelationalParser) LengthTwoDimension

func (p *RelationalParser) LengthTwoDimension() (localctx ILengthTwoDimensionContext)

func (*RelationalParser) LengthTwoOptionalDimension

func (p *RelationalParser) LengthTwoOptionalDimension() (localctx ILengthTwoOptionalDimensionContext)

func (*RelationalParser) LevelInWeightListElement

func (p *RelationalParser) LevelInWeightListElement() (localctx ILevelInWeightListElementContext)

func (*RelationalParser) LevelsInWeightString

func (p *RelationalParser) LevelsInWeightString() (localctx ILevelsInWeightStringContext)

func (*RelationalParser) LimitClause

func (p *RelationalParser) LimitClause() (localctx ILimitClauseContext)

func (*RelationalParser) LimitClauseAtom

func (p *RelationalParser) LimitClauseAtom() (localctx ILimitClauseAtomContext)

func (*RelationalParser) LoadedTableIndexes

func (p *RelationalParser) LoadedTableIndexes() (localctx ILoadedTableIndexesContext)

func (*RelationalParser) LogicalOperator

func (p *RelationalParser) LogicalOperator() (localctx ILogicalOperatorContext)

func (*RelationalParser) MathOperator

func (p *RelationalParser) MathOperator() (localctx IMathOperatorContext)

func (*RelationalParser) NamedFunctionArg

func (p *RelationalParser) NamedFunctionArg() (localctx INamedFunctionArgContext)

func (*RelationalParser) NamedOrUnnamedFunctionArgs

func (p *RelationalParser) NamedOrUnnamedFunctionArgs() (localctx INamedOrUnnamedFunctionArgsContext)

func (*RelationalParser) NamedQuery

func (p *RelationalParser) NamedQuery() (localctx INamedQueryContext)

func (*RelationalParser) NonAggregateWindowedFunction

func (p *RelationalParser) NonAggregateWindowedFunction() (localctx INonAggregateWindowedFunctionContext)

func (*RelationalParser) NullCallClause

func (p *RelationalParser) NullCallClause() (localctx INullCallClauseContext)

func (*RelationalParser) NullLiteral

func (p *RelationalParser) NullLiteral() (localctx INullLiteralContext)

func (*RelationalParser) NullNotnull

func (p *RelationalParser) NullNotnull() (localctx INullNotnullContext)

func (*RelationalParser) NullTreatmentClause

func (p *RelationalParser) NullTreatmentClause() (localctx INullTreatmentClauseContext)

func (*RelationalParser) OfTypeClause

func (p *RelationalParser) OfTypeClause() (localctx IOfTypeClauseContext)

func (*RelationalParser) Option

func (p *RelationalParser) Option() (localctx IOptionContext)

func (*RelationalParser) OptionsClause

func (p *RelationalParser) OptionsClause() (localctx IOptionsClauseContext)

func (*RelationalParser) OrderByClause

func (p *RelationalParser) OrderByClause() (localctx IOrderByClauseContext)

func (*RelationalParser) OrderByExpression

func (p *RelationalParser) OrderByExpression() (localctx IOrderByExpressionContext)

func (*RelationalParser) OrderClause

func (p *RelationalParser) OrderClause() (localctx IOrderClauseContext)

func (*RelationalParser) OverClause

func (p *RelationalParser) OverClause() (localctx IOverClauseContext)

func (*RelationalParser) ParameterMode

func (p *RelationalParser) ParameterMode() (localctx IParameterModeContext)

func (*RelationalParser) ParameterStyle

func (p *RelationalParser) ParameterStyle() (localctx IParameterStyleContext)

func (*RelationalParser) PartitionClause

func (p *RelationalParser) PartitionClause() (localctx IPartitionClauseContext)

func (*RelationalParser) Path

func (p *RelationalParser) Path() (localctx IPathContext)

func (*RelationalParser) Predicate

func (p *RelationalParser) Predicate() (localctx IPredicateContext)

func (*RelationalParser) PrepareStatement

func (p *RelationalParser) PrepareStatement() (localctx IPrepareStatementContext)

func (*RelationalParser) PreparedStatement

func (p *RelationalParser) PreparedStatement() (localctx IPreparedStatementContext)

func (*RelationalParser) PreparedStatementParameter

func (p *RelationalParser) PreparedStatementParameter() (localctx IPreparedStatementParameterContext)

func (*RelationalParser) PrimaryKeyDefinition

func (p *RelationalParser) PrimaryKeyDefinition() (localctx IPrimaryKeyDefinitionContext)

func (*RelationalParser) PrimitiveType

func (p *RelationalParser) PrimitiveType() (localctx IPrimitiveTypeContext)

func (*RelationalParser) QualifyClause

func (p *RelationalParser) QualifyClause() (localctx IQualifyClauseContext)

func (*RelationalParser) Query

func (p *RelationalParser) Query() (localctx IQueryContext)

func (*RelationalParser) QueryExpressionBody

func (p *RelationalParser) QueryExpressionBody() (localctx IQueryExpressionBodyContext)

func (*RelationalParser) QueryExpressionBody_Sempred

func (p *RelationalParser) QueryExpressionBody_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*RelationalParser) QueryTerm

func (p *RelationalParser) QueryTerm() (localctx IQueryTermContext)

func (*RelationalParser) RecordConstructor

func (p *RelationalParser) RecordConstructor() (localctx IRecordConstructorContext)

func (*RelationalParser) RecordConstructorForInlineTable

func (p *RelationalParser) RecordConstructorForInlineTable() (localctx IRecordConstructorForInlineTableContext)

func (*RelationalParser) RecordConstructorForInsert

func (p *RelationalParser) RecordConstructorForInsert() (localctx IRecordConstructorForInsertContext)

func (*RelationalParser) ResetStatement

func (p *RelationalParser) ResetStatement() (localctx IResetStatementContext)

func (*RelationalParser) ReturnsClause

func (p *RelationalParser) ReturnsClause() (localctx IReturnsClauseContext)

func (*RelationalParser) ReturnsTableType

func (p *RelationalParser) ReturnsTableType() (localctx IReturnsTableTypeContext)

func (*RelationalParser) ReturnsType

func (p *RelationalParser) ReturnsType() (localctx IReturnsTypeContext)

func (*RelationalParser) RollbackStatement

func (p *RelationalParser) RollbackStatement() (localctx IRollbackStatementContext)

func (*RelationalParser) Root

func (p *RelationalParser) Root() (localctx IRootContext)

func (*RelationalParser) RoutineBody

func (p *RelationalParser) RoutineBody() (localctx IRoutineBodyContext)

func (*RelationalParser) RoutineCharacteristics

func (p *RelationalParser) RoutineCharacteristics() (localctx IRoutineCharacteristicsContext)

func (*RelationalParser) ScalarFunctionName

func (p *RelationalParser) ScalarFunctionName() (localctx IScalarFunctionNameContext)

func (*RelationalParser) SchemaId

func (p *RelationalParser) SchemaId() (localctx ISchemaIdContext)

func (*RelationalParser) SchemaTemplateId

func (p *RelationalParser) SchemaTemplateId() (localctx ISchemaTemplateIdContext)

func (*RelationalParser) SelectElement

func (p *RelationalParser) SelectElement() (localctx ISelectElementContext)

func (*RelationalParser) SelectElements

func (p *RelationalParser) SelectElements() (localctx ISelectElementsContext)

func (*RelationalParser) SelectStatement

func (p *RelationalParser) SelectStatement() (localctx ISelectStatementContext)

func (*RelationalParser) Sempred

func (p *RelationalParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

func (*RelationalParser) SetAutocommitStatement

func (p *RelationalParser) SetAutocommitStatement() (localctx ISetAutocommitStatementContext)

func (*RelationalParser) SetStatement

func (p *RelationalParser) SetStatement() (localctx ISetStatementContext)

func (*RelationalParser) SetTransactionStatement

func (p *RelationalParser) SetTransactionStatement() (localctx ISetTransactionStatementContext)

func (*RelationalParser) ShowStatement

func (p *RelationalParser) ShowStatement() (localctx IShowStatementContext)

func (*RelationalParser) SimpleDescribeStatement

func (p *RelationalParser) SimpleDescribeStatement() (localctx ISimpleDescribeStatementContext)

func (*RelationalParser) SimpleId

func (p *RelationalParser) SimpleId() (localctx ISimpleIdContext)

func (*RelationalParser) SpecificFunction

func (p *RelationalParser) SpecificFunction() (localctx ISpecificFunctionContext)

func (*RelationalParser) SqlInvokedFunction

func (p *RelationalParser) SqlInvokedFunction() (localctx ISqlInvokedFunctionContext)

func (*RelationalParser) SqlParameterDeclaration

func (p *RelationalParser) SqlParameterDeclaration() (localctx ISqlParameterDeclarationContext)

func (*RelationalParser) SqlParameterDeclarationList

func (p *RelationalParser) SqlParameterDeclarationList() (localctx ISqlParameterDeclarationListContext)

func (*RelationalParser) SqlParameterDeclarations

func (p *RelationalParser) SqlParameterDeclarations() (localctx ISqlParameterDeclarationsContext)

func (*RelationalParser) StartTransaction

func (p *RelationalParser) StartTransaction() (localctx IStartTransactionContext)

func (*RelationalParser) Statement

func (p *RelationalParser) Statement() (localctx IStatementContext)

func (*RelationalParser) StatementOption

func (p *RelationalParser) StatementOption() (localctx IStatementOptionContext)

func (*RelationalParser) StatementOptions

func (p *RelationalParser) StatementOptions() (localctx IStatementOptionsContext)

func (*RelationalParser) Statements

func (p *RelationalParser) Statements() (localctx IStatementsContext)

func (*RelationalParser) StoredQueryDefinition

func (p *RelationalParser) StoredQueryDefinition() (localctx IStoredQueryDefinitionContext)

func (*RelationalParser) StringLiteral

func (p *RelationalParser) StringLiteral() (localctx IStringLiteralContext)

func (*RelationalParser) StructDefinition

func (p *RelationalParser) StructDefinition() (localctx IStructDefinitionContext)

func (*RelationalParser) TableDefinition

func (p *RelationalParser) TableDefinition() (localctx ITableDefinitionContext)

func (*RelationalParser) TableFunction

func (p *RelationalParser) TableFunction() (localctx ITableFunctionContext)

func (*RelationalParser) TableFunctionColumnList

func (p *RelationalParser) TableFunctionColumnList() (localctx ITableFunctionColumnListContext)

func (*RelationalParser) TableFunctionColumnListElement

func (p *RelationalParser) TableFunctionColumnListElement() (localctx ITableFunctionColumnListElementContext)

func (*RelationalParser) TableFunctionName

func (p *RelationalParser) TableFunctionName() (localctx ITableFunctionNameContext)

func (*RelationalParser) TableIndexes

func (p *RelationalParser) TableIndexes() (localctx ITableIndexesContext)

func (*RelationalParser) TableName

func (p *RelationalParser) TableName() (localctx ITableNameContext)

func (*RelationalParser) TableSource

func (p *RelationalParser) TableSource() (localctx ITableSourceContext)

func (*RelationalParser) TableSourceItem

func (p *RelationalParser) TableSourceItem() (localctx ITableSourceItemContext)

func (*RelationalParser) TableSources

func (p *RelationalParser) TableSources() (localctx ITableSourcesContext)

func (*RelationalParser) Tables

func (p *RelationalParser) Tables() (localctx ITablesContext)

func (*RelationalParser) TempSqlInvokedFunction

func (p *RelationalParser) TempSqlInvokedFunction() (localctx ITempSqlInvokedFunctionContext)

func (*RelationalParser) TemplateClause

func (p *RelationalParser) TemplateClause() (localctx ITemplateClauseContext)

func (*RelationalParser) TransactionLevel

func (p *RelationalParser) TransactionLevel() (localctx ITransactionLevelContext)

func (*RelationalParser) TransactionOption

func (p *RelationalParser) TransactionOption() (localctx ITransactionOptionContext)

func (*RelationalParser) TransactionStatement

func (p *RelationalParser) TransactionStatement() (localctx ITransactionStatementContext)

func (*RelationalParser) TraversalOrderClause

func (p *RelationalParser) TraversalOrderClause() (localctx ITraversalOrderClauseContext)

func (*RelationalParser) Uid

func (p *RelationalParser) Uid() (localctx IUidContext)

func (*RelationalParser) UidList

func (p *RelationalParser) UidList() (localctx IUidListContext)

func (*RelationalParser) UidListWithNestings

func (p *RelationalParser) UidListWithNestings() (localctx IUidListWithNestingsContext)

func (*RelationalParser) UidListWithNestingsInParens

func (p *RelationalParser) UidListWithNestingsInParens() (localctx IUidListWithNestingsInParensContext)

func (*RelationalParser) UidWithNestings

func (p *RelationalParser) UidWithNestings() (localctx IUidWithNestingsContext)

func (*RelationalParser) UnaryOperator

func (p *RelationalParser) UnaryOperator() (localctx IUnaryOperatorContext)

func (*RelationalParser) UpdateStatement

func (p *RelationalParser) UpdateStatement() (localctx IUpdateStatementContext)

func (*RelationalParser) UpdatedElement

func (p *RelationalParser) UpdatedElement() (localctx IUpdatedElementContext)

func (*RelationalParser) UserDefinedScalarFunctionName

func (p *RelationalParser) UserDefinedScalarFunctionName() (localctx IUserDefinedScalarFunctionNameContext)

func (*RelationalParser) UserVariables

func (p *RelationalParser) UserVariables() (localctx IUserVariablesContext)

func (*RelationalParser) UtilityStatement

func (p *RelationalParser) UtilityStatement() (localctx IUtilityStatementContext)

func (*RelationalParser) VariableClause

func (p *RelationalParser) VariableClause() (localctx IVariableClauseContext)

func (*RelationalParser) VectorElementType

func (p *RelationalParser) VectorElementType() (localctx IVectorElementTypeContext)

func (*RelationalParser) VectorEngine

func (p *RelationalParser) VectorEngine() (localctx IVectorEngineContext)

func (*RelationalParser) VectorIndexOption

func (p *RelationalParser) VectorIndexOption() (localctx IVectorIndexOptionContext)

func (*RelationalParser) VectorIndexOptionValue

func (p *RelationalParser) VectorIndexOptionValue() (localctx IVectorIndexOptionValueContext)

func (*RelationalParser) VectorIndexOptions

func (p *RelationalParser) VectorIndexOptions() (localctx IVectorIndexOptionsContext)

func (*RelationalParser) VectorType

func (p *RelationalParser) VectorType() (localctx IVectorTypeContext)

func (*RelationalParser) ViewDefinition

func (p *RelationalParser) ViewDefinition() (localctx IViewDefinitionContext)

func (*RelationalParser) WhereExpr

func (p *RelationalParser) WhereExpr() (localctx IWhereExprContext)

func (*RelationalParser) WindowName

func (p *RelationalParser) WindowName() (localctx IWindowNameContext)

func (*RelationalParser) WindowOption

func (p *RelationalParser) WindowOption() (localctx IWindowOptionContext)

func (*RelationalParser) WindowOptionsClause

func (p *RelationalParser) WindowOptionsClause() (localctx IWindowOptionsClauseContext)

func (*RelationalParser) WindowSpec

func (p *RelationalParser) WindowSpec() (localctx IWindowSpecContext)

type RelationalParserListener

type RelationalParserListener interface {
	antlr.ParseTreeListener

	// EnterRoot is called when entering the root production.
	EnterRoot(c *RootContext)

	// EnterStatements is called when entering the statements production.
	EnterStatements(c *StatementsContext)

	// EnterStatement is called when entering the statement production.
	EnterStatement(c *StatementContext)

	// EnterDmlStatement is called when entering the dmlStatement production.
	EnterDmlStatement(c *DmlStatementContext)

	// EnterDdlStatement is called when entering the ddlStatement production.
	EnterDdlStatement(c *DdlStatementContext)

	// EnterTransactionStatement is called when entering the transactionStatement production.
	EnterTransactionStatement(c *TransactionStatementContext)

	// EnterPreparedStatement is called when entering the preparedStatement production.
	EnterPreparedStatement(c *PreparedStatementContext)

	// EnterAdministrationStatement is called when entering the administrationStatement production.
	EnterAdministrationStatement(c *AdministrationStatementContext)

	// EnterUtilityStatement is called when entering the utilityStatement production.
	EnterUtilityStatement(c *UtilityStatementContext)

	// EnterTemplateClause is called when entering the templateClause production.
	EnterTemplateClause(c *TemplateClauseContext)

	// EnterCreateSchemaStatement is called when entering the createSchemaStatement production.
	EnterCreateSchemaStatement(c *CreateSchemaStatementContext)

	// EnterCreateSchemaTemplateStatement is called when entering the createSchemaTemplateStatement production.
	EnterCreateSchemaTemplateStatement(c *CreateSchemaTemplateStatementContext)

	// EnterCreateDatabaseStatement is called when entering the createDatabaseStatement production.
	EnterCreateDatabaseStatement(c *CreateDatabaseStatementContext)

	// EnterOptionsClause is called when entering the optionsClause production.
	EnterOptionsClause(c *OptionsClauseContext)

	// EnterOption is called when entering the option production.
	EnterOption(c *OptionContext)

	// EnterDropDatabaseStatement is called when entering the dropDatabaseStatement production.
	EnterDropDatabaseStatement(c *DropDatabaseStatementContext)

	// EnterDropSchemaTemplateStatement is called when entering the dropSchemaTemplateStatement production.
	EnterDropSchemaTemplateStatement(c *DropSchemaTemplateStatementContext)

	// EnterDropSchemaStatement is called when entering the dropSchemaStatement production.
	EnterDropSchemaStatement(c *DropSchemaStatementContext)

	// EnterStructDefinition is called when entering the structDefinition production.
	EnterStructDefinition(c *StructDefinitionContext)

	// EnterTableDefinition is called when entering the tableDefinition production.
	EnterTableDefinition(c *TableDefinitionContext)

	// EnterColumnDefinition is called when entering the columnDefinition production.
	EnterColumnDefinition(c *ColumnDefinitionContext)

	// EnterFunctionColumnType is called when entering the functionColumnType production.
	EnterFunctionColumnType(c *FunctionColumnTypeContext)

	// EnterColumnType is called when entering the columnType production.
	EnterColumnType(c *ColumnTypeContext)

	// EnterPrimitiveType is called when entering the primitiveType production.
	EnterPrimitiveType(c *PrimitiveTypeContext)

	// EnterVectorType is called when entering the vectorType production.
	EnterVectorType(c *VectorTypeContext)

	// EnterVectorElementType is called when entering the vectorElementType production.
	EnterVectorElementType(c *VectorElementTypeContext)

	// EnterNullColumnConstraint is called when entering the nullColumnConstraint production.
	EnterNullColumnConstraint(c *NullColumnConstraintContext)

	// EnterPrimaryKeyDefinition is called when entering the primaryKeyDefinition production.
	EnterPrimaryKeyDefinition(c *PrimaryKeyDefinitionContext)

	// EnterFullIdList is called when entering the fullIdList production.
	EnterFullIdList(c *FullIdListContext)

	// EnterEnumDefinition is called when entering the enumDefinition production.
	EnterEnumDefinition(c *EnumDefinitionContext)

	// EnterIndexAsSelectDefinition is called when entering the indexAsSelectDefinition production.
	EnterIndexAsSelectDefinition(c *IndexAsSelectDefinitionContext)

	// EnterIndexOnSourceDefinition is called when entering the indexOnSourceDefinition production.
	EnterIndexOnSourceDefinition(c *IndexOnSourceDefinitionContext)

	// EnterVectorIndexDefinition is called when entering the vectorIndexDefinition production.
	EnterVectorIndexDefinition(c *VectorIndexDefinitionContext)

	// EnterVectorEngine is called when entering the vectorEngine production.
	EnterVectorEngine(c *VectorEngineContext)

	// EnterIndexColumnList is called when entering the indexColumnList production.
	EnterIndexColumnList(c *IndexColumnListContext)

	// EnterIndexColumnSpec is called when entering the indexColumnSpec production.
	EnterIndexColumnSpec(c *IndexColumnSpecContext)

	// EnterIncludeClause is called when entering the includeClause production.
	EnterIncludeClause(c *IncludeClauseContext)

	// EnterIndexType is called when entering the indexType production.
	EnterIndexType(c *IndexTypeContext)

	// EnterIndexPartitionClause is called when entering the indexPartitionClause production.
	EnterIndexPartitionClause(c *IndexPartitionClauseContext)

	// EnterIndexOptions is called when entering the indexOptions production.
	EnterIndexOptions(c *IndexOptionsContext)

	// EnterIndexOption is called when entering the indexOption production.
	EnterIndexOption(c *IndexOptionContext)

	// EnterVectorIndexOptions is called when entering the vectorIndexOptions production.
	EnterVectorIndexOptions(c *VectorIndexOptionsContext)

	// EnterVectorIndexOption is called when entering the vectorIndexOption production.
	EnterVectorIndexOption(c *VectorIndexOptionContext)

	// EnterVectorIndexOptionValue is called when entering the vectorIndexOptionValue production.
	EnterVectorIndexOptionValue(c *VectorIndexOptionValueContext)

	// EnterHnswMetric is called when entering the hnswMetric production.
	EnterHnswMetric(c *HnswMetricContext)

	// EnterIndexAttributes is called when entering the indexAttributes production.
	EnterIndexAttributes(c *IndexAttributesContext)

	// EnterIndexAttribute is called when entering the indexAttribute production.
	EnterIndexAttribute(c *IndexAttributeContext)

	// EnterCreateTempFunction is called when entering the createTempFunction production.
	EnterCreateTempFunction(c *CreateTempFunctionContext)

	// EnterDropTempFunction is called when entering the dropTempFunction production.
	EnterDropTempFunction(c *DropTempFunctionContext)

	// EnterViewDefinition is called when entering the viewDefinition production.
	EnterViewDefinition(c *ViewDefinitionContext)

	// EnterStoredQueryDefinition is called when entering the storedQueryDefinition production.
	EnterStoredQueryDefinition(c *StoredQueryDefinitionContext)

	// EnterDeclareBlock is called when entering the declareBlock production.
	EnterDeclareBlock(c *DeclareBlockContext)

	// EnterDeclaredFunction is called when entering the declaredFunction production.
	EnterDeclaredFunction(c *DeclaredFunctionContext)

	// EnterTempSqlInvokedFunction is called when entering the tempSqlInvokedFunction production.
	EnterTempSqlInvokedFunction(c *TempSqlInvokedFunctionContext)

	// EnterSqlInvokedFunction is called when entering the sqlInvokedFunction production.
	EnterSqlInvokedFunction(c *SqlInvokedFunctionContext)

	// EnterFunctionSpecification is called when entering the functionSpecification production.
	EnterFunctionSpecification(c *FunctionSpecificationContext)

	// EnterSqlParameterDeclarationList is called when entering the sqlParameterDeclarationList production.
	EnterSqlParameterDeclarationList(c *SqlParameterDeclarationListContext)

	// EnterSqlParameterDeclarations is called when entering the sqlParameterDeclarations production.
	EnterSqlParameterDeclarations(c *SqlParameterDeclarationsContext)

	// EnterSqlParameterDeclaration is called when entering the sqlParameterDeclaration production.
	EnterSqlParameterDeclaration(c *SqlParameterDeclarationContext)

	// EnterParameterMode is called when entering the parameterMode production.
	EnterParameterMode(c *ParameterModeContext)

	// EnterReturnsClause is called when entering the returnsClause production.
	EnterReturnsClause(c *ReturnsClauseContext)

	// EnterReturnsType is called when entering the returnsType production.
	EnterReturnsType(c *ReturnsTypeContext)

	// EnterReturnsTableType is called when entering the returnsTableType production.
	EnterReturnsTableType(c *ReturnsTableTypeContext)

	// EnterTableFunctionColumnList is called when entering the tableFunctionColumnList production.
	EnterTableFunctionColumnList(c *TableFunctionColumnListContext)

	// EnterTableFunctionColumnListElement is called when entering the tableFunctionColumnListElement production.
	EnterTableFunctionColumnListElement(c *TableFunctionColumnListElementContext)

	// EnterRoutineCharacteristics is called when entering the routineCharacteristics production.
	EnterRoutineCharacteristics(c *RoutineCharacteristicsContext)

	// EnterLanguageClause is called when entering the languageClause production.
	EnterLanguageClause(c *LanguageClauseContext)

	// EnterLanguageName is called when entering the languageName production.
	EnterLanguageName(c *LanguageNameContext)

	// EnterParameterStyle is called when entering the parameterStyle production.
	EnterParameterStyle(c *ParameterStyleContext)

	// EnterDeterministicCharacteristic is called when entering the deterministicCharacteristic production.
	EnterDeterministicCharacteristic(c *DeterministicCharacteristicContext)

	// EnterNullCallClause is called when entering the nullCallClause production.
	EnterNullCallClause(c *NullCallClauseContext)

	// EnterDispatchClause is called when entering the dispatchClause production.
	EnterDispatchClause(c *DispatchClauseContext)

	// EnterStatementBody is called when entering the statementBody production.
	EnterStatementBody(c *StatementBodyContext)

	// EnterUserDefinedMacroFunctionStatementBody is called when entering the userDefinedMacroFunctionStatementBody production.
	EnterUserDefinedMacroFunctionStatementBody(c *UserDefinedMacroFunctionStatementBodyContext)

	// EnterCharSet is called when entering the charSet production.
	EnterCharSet(c *CharSetContext)

	// EnterIntervalType is called when entering the intervalType production.
	EnterIntervalType(c *IntervalTypeContext)

	// EnterSchemaId is called when entering the schemaId production.
	EnterSchemaId(c *SchemaIdContext)

	// EnterPath is called when entering the path production.
	EnterPath(c *PathContext)

	// EnterSchemaTemplateId is called when entering the schemaTemplateId production.
	EnterSchemaTemplateId(c *SchemaTemplateIdContext)

	// EnterDeleteStatement is called when entering the deleteStatement production.
	EnterDeleteStatement(c *DeleteStatementContext)

	// EnterInsertStatement is called when entering the insertStatement production.
	EnterInsertStatement(c *InsertStatementContext)

	// EnterContinuationAtom is called when entering the continuationAtom production.
	EnterContinuationAtom(c *ContinuationAtomContext)

	// EnterSelectStatement is called when entering the selectStatement production.
	EnterSelectStatement(c *SelectStatementContext)

	// EnterQuery is called when entering the query production.
	EnterQuery(c *QueryContext)

	// EnterCtes is called when entering the ctes production.
	EnterCtes(c *CtesContext)

	// EnterTraversalOrderClause is called when entering the traversalOrderClause production.
	EnterTraversalOrderClause(c *TraversalOrderClauseContext)

	// EnterNamedQuery is called when entering the namedQuery production.
	EnterNamedQuery(c *NamedQueryContext)

	// EnterTableFunction is called when entering the tableFunction production.
	EnterTableFunction(c *TableFunctionContext)

	// EnterNamedOrUnnamedFunctionArgs is called when entering the namedOrUnnamedFunctionArgs production.
	EnterNamedOrUnnamedFunctionArgs(c *NamedOrUnnamedFunctionArgsContext)

	// EnterTableFunctionName is called when entering the tableFunctionName production.
	EnterTableFunctionName(c *TableFunctionNameContext)

	// EnterQueryTermDefault is called when entering the queryTermDefault production.
	EnterQueryTermDefault(c *QueryTermDefaultContext)

	// EnterSetQuery is called when entering the setQuery production.
	EnterSetQuery(c *SetQueryContext)

	// EnterInsertStatementValueSelect is called when entering the insertStatementValueSelect production.
	EnterInsertStatementValueSelect(c *InsertStatementValueSelectContext)

	// EnterInsertStatementValueValues is called when entering the insertStatementValueValues production.
	EnterInsertStatementValueValues(c *InsertStatementValueValuesContext)

	// EnterUpdatedElement is called when entering the updatedElement production.
	EnterUpdatedElement(c *UpdatedElementContext)

	// EnterAssignmentField is called when entering the assignmentField production.
	EnterAssignmentField(c *AssignmentFieldContext)

	// EnterUpdateStatement is called when entering the updateStatement production.
	EnterUpdateStatement(c *UpdateStatementContext)

	// EnterOrderByClause is called when entering the orderByClause production.
	EnterOrderByClause(c *OrderByClauseContext)

	// EnterOrderByExpression is called when entering the orderByExpression production.
	EnterOrderByExpression(c *OrderByExpressionContext)

	// EnterOrderClause is called when entering the orderClause production.
	EnterOrderClause(c *OrderClauseContext)

	// EnterTableSources is called when entering the tableSources production.
	EnterTableSources(c *TableSourcesContext)

	// EnterTableSourceBase is called when entering the tableSourceBase production.
	EnterTableSourceBase(c *TableSourceBaseContext)

	// EnterAtomTableItem is called when entering the atomTableItem production.
	EnterAtomTableItem(c *AtomTableItemContext)

	// EnterSubqueryTableItem is called when entering the subqueryTableItem production.
	EnterSubqueryTableItem(c *SubqueryTableItemContext)

	// EnterInlineTableItem is called when entering the inlineTableItem production.
	EnterInlineTableItem(c *InlineTableItemContext)

	// EnterTableValuedFunction is called when entering the tableValuedFunction production.
	EnterTableValuedFunction(c *TableValuedFunctionContext)

	// EnterIndexHint is called when entering the indexHint production.
	EnterIndexHint(c *IndexHintContext)

	// EnterIndexHintType is called when entering the indexHintType production.
	EnterIndexHintType(c *IndexHintTypeContext)

	// EnterInlineTableDefinition is called when entering the inlineTableDefinition production.
	EnterInlineTableDefinition(c *InlineTableDefinitionContext)

	// EnterInnerJoin is called when entering the innerJoin production.
	EnterInnerJoin(c *InnerJoinContext)

	// EnterStraightJoin is called when entering the straightJoin production.
	EnterStraightJoin(c *StraightJoinContext)

	// EnterOuterJoin is called when entering the outerJoin production.
	EnterOuterJoin(c *OuterJoinContext)

	// EnterNaturalJoin is called when entering the naturalJoin production.
	EnterNaturalJoin(c *NaturalJoinContext)

	// EnterSimpleTable is called when entering the simpleTable production.
	EnterSimpleTable(c *SimpleTableContext)

	// EnterParenthesisQuery is called when entering the parenthesisQuery production.
	EnterParenthesisQuery(c *ParenthesisQueryContext)

	// EnterSelectElements is called when entering the selectElements production.
	EnterSelectElements(c *SelectElementsContext)

	// EnterSelectStarElement is called when entering the selectStarElement production.
	EnterSelectStarElement(c *SelectStarElementContext)

	// EnterSelectQualifierStarElement is called when entering the selectQualifierStarElement production.
	EnterSelectQualifierStarElement(c *SelectQualifierStarElementContext)

	// EnterSelectExpressionElement is called when entering the selectExpressionElement production.
	EnterSelectExpressionElement(c *SelectExpressionElementContext)

	// EnterFromClause is called when entering the fromClause production.
	EnterFromClause(c *FromClauseContext)

	// EnterGroupByClause is called when entering the groupByClause production.
	EnterGroupByClause(c *GroupByClauseContext)

	// EnterWhereExpr is called when entering the whereExpr production.
	EnterWhereExpr(c *WhereExprContext)

	// EnterHavingClause is called when entering the havingClause production.
	EnterHavingClause(c *HavingClauseContext)

	// EnterQualifyClause is called when entering the qualifyClause production.
	EnterQualifyClause(c *QualifyClauseContext)

	// EnterGroupByItem is called when entering the groupByItem production.
	EnterGroupByItem(c *GroupByItemContext)

	// EnterLimitClause is called when entering the limitClause production.
	EnterLimitClause(c *LimitClauseContext)

	// EnterLimitClauseAtom is called when entering the limitClauseAtom production.
	EnterLimitClauseAtom(c *LimitClauseAtomContext)

	// EnterStatementOptions is called when entering the statementOptions production.
	EnterStatementOptions(c *StatementOptionsContext)

	// EnterStatementOption is called when entering the statementOption production.
	EnterStatementOption(c *StatementOptionContext)

	// EnterStartTransaction is called when entering the startTransaction production.
	EnterStartTransaction(c *StartTransactionContext)

	// EnterCommitStatement is called when entering the commitStatement production.
	EnterCommitStatement(c *CommitStatementContext)

	// EnterRollbackStatement is called when entering the rollbackStatement production.
	EnterRollbackStatement(c *RollbackStatementContext)

	// EnterSetAutocommitStatement is called when entering the setAutocommitStatement production.
	EnterSetAutocommitStatement(c *SetAutocommitStatementContext)

	// EnterSetTransactionStatement is called when entering the setTransactionStatement production.
	EnterSetTransactionStatement(c *SetTransactionStatementContext)

	// EnterTransactionOption is called when entering the transactionOption production.
	EnterTransactionOption(c *TransactionOptionContext)

	// EnterTransactionLevel is called when entering the transactionLevel production.
	EnterTransactionLevel(c *TransactionLevelContext)

	// EnterPrepareStatement is called when entering the prepareStatement production.
	EnterPrepareStatement(c *PrepareStatementContext)

	// EnterExecuteStatement is called when entering the executeStatement production.
	EnterExecuteStatement(c *ExecuteStatementContext)

	// EnterShowDatabasesStatement is called when entering the showDatabasesStatement production.
	EnterShowDatabasesStatement(c *ShowDatabasesStatementContext)

	// EnterShowSchemaTemplatesStatement is called when entering the showSchemaTemplatesStatement production.
	EnterShowSchemaTemplatesStatement(c *ShowSchemaTemplatesStatementContext)

	// EnterSetVariable is called when entering the setVariable production.
	EnterSetVariable(c *SetVariableContext)

	// EnterSetCharset is called when entering the setCharset production.
	EnterSetCharset(c *SetCharsetContext)

	// EnterSetNames is called when entering the setNames production.
	EnterSetNames(c *SetNamesContext)

	// EnterSetTransaction is called when entering the setTransaction production.
	EnterSetTransaction(c *SetTransactionContext)

	// EnterSetAutocommit is called when entering the setAutocommit production.
	EnterSetAutocommit(c *SetAutocommitContext)

	// EnterSetNewValueInsideTrigger is called when entering the setNewValueInsideTrigger production.
	EnterSetNewValueInsideTrigger(c *SetNewValueInsideTriggerContext)

	// EnterVariableClause is called when entering the variableClause production.
	EnterVariableClause(c *VariableClauseContext)

	// EnterKillStatement is called when entering the killStatement production.
	EnterKillStatement(c *KillStatementContext)

	// EnterResetStatement is called when entering the resetStatement production.
	EnterResetStatement(c *ResetStatementContext)

	// EnterExecuteContinuationStatement is called when entering the executeContinuationStatement production.
	EnterExecuteContinuationStatement(c *ExecuteContinuationStatementContext)

	// EnterCopyExportStatement is called when entering the copyExportStatement production.
	EnterCopyExportStatement(c *CopyExportStatementContext)

	// EnterCopyImportStatement is called when entering the copyImportStatement production.
	EnterCopyImportStatement(c *CopyImportStatementContext)

	// EnterTableIndexes is called when entering the tableIndexes production.
	EnterTableIndexes(c *TableIndexesContext)

	// EnterLoadedTableIndexes is called when entering the loadedTableIndexes production.
	EnterLoadedTableIndexes(c *LoadedTableIndexesContext)

	// EnterSimpleDescribeSchemaStatement is called when entering the simpleDescribeSchemaStatement production.
	EnterSimpleDescribeSchemaStatement(c *SimpleDescribeSchemaStatementContext)

	// EnterSimpleDescribeSchemaTemplateStatement is called when entering the simpleDescribeSchemaTemplateStatement production.
	EnterSimpleDescribeSchemaTemplateStatement(c *SimpleDescribeSchemaTemplateStatementContext)

	// EnterFullDescribeStatement is called when entering the fullDescribeStatement production.
	EnterFullDescribeStatement(c *FullDescribeStatementContext)

	// EnterHelpStatement is called when entering the helpStatement production.
	EnterHelpStatement(c *HelpStatementContext)

	// EnterDescribeStatements is called when entering the describeStatements production.
	EnterDescribeStatements(c *DescribeStatementsContext)

	// EnterDescribeConnection is called when entering the describeConnection production.
	EnterDescribeConnection(c *DescribeConnectionContext)

	// EnterFullId is called when entering the fullId production.
	EnterFullId(c *FullIdContext)

	// EnterTableName is called when entering the tableName production.
	EnterTableName(c *TableNameContext)

	// EnterFullColumnName is called when entering the fullColumnName production.
	EnterFullColumnName(c *FullColumnNameContext)

	// EnterIndexColumnName is called when entering the indexColumnName production.
	EnterIndexColumnName(c *IndexColumnNameContext)

	// EnterCharsetName is called when entering the charsetName production.
	EnterCharsetName(c *CharsetNameContext)

	// EnterCollationName is called when entering the collationName production.
	EnterCollationName(c *CollationNameContext)

	// EnterUid is called when entering the uid production.
	EnterUid(c *UidContext)

	// EnterSimpleId is called when entering the simpleId production.
	EnterSimpleId(c *SimpleIdContext)

	// EnterNullNotnull is called when entering the nullNotnull production.
	EnterNullNotnull(c *NullNotnullContext)

	// EnterDecimalLiteral is called when entering the decimalLiteral production.
	EnterDecimalLiteral(c *DecimalLiteralContext)

	// EnterStringLiteral is called when entering the stringLiteral production.
	EnterStringLiteral(c *StringLiteralContext)

	// EnterBooleanLiteral is called when entering the booleanLiteral production.
	EnterBooleanLiteral(c *BooleanLiteralContext)

	// EnterBytesLiteral is called when entering the bytesLiteral production.
	EnterBytesLiteral(c *BytesLiteralContext)

	// EnterNullLiteral is called when entering the nullLiteral production.
	EnterNullLiteral(c *NullLiteralContext)

	// EnterStringConstant is called when entering the stringConstant production.
	EnterStringConstant(c *StringConstantContext)

	// EnterDecimalConstant is called when entering the decimalConstant production.
	EnterDecimalConstant(c *DecimalConstantContext)

	// EnterNegativeDecimalConstant is called when entering the negativeDecimalConstant production.
	EnterNegativeDecimalConstant(c *NegativeDecimalConstantContext)

	// EnterBytesConstant is called when entering the bytesConstant production.
	EnterBytesConstant(c *BytesConstantContext)

	// EnterBooleanConstant is called when entering the booleanConstant production.
	EnterBooleanConstant(c *BooleanConstantContext)

	// EnterBitStringConstant is called when entering the bitStringConstant production.
	EnterBitStringConstant(c *BitStringConstantContext)

	// EnterNullConstant is called when entering the nullConstant production.
	EnterNullConstant(c *NullConstantContext)

	// EnterStringDataType is called when entering the stringDataType production.
	EnterStringDataType(c *StringDataTypeContext)

	// EnterNationalStringDataType is called when entering the nationalStringDataType production.
	EnterNationalStringDataType(c *NationalStringDataTypeContext)

	// EnterNationalVaryingStringDataType is called when entering the nationalVaryingStringDataType production.
	EnterNationalVaryingStringDataType(c *NationalVaryingStringDataTypeContext)

	// EnterDimensionDataType is called when entering the dimensionDataType production.
	EnterDimensionDataType(c *DimensionDataTypeContext)

	// EnterSimpleDataType is called when entering the simpleDataType production.
	EnterSimpleDataType(c *SimpleDataTypeContext)

	// EnterCollectionDataType is called when entering the collectionDataType production.
	EnterCollectionDataType(c *CollectionDataTypeContext)

	// EnterSpatialDataType is called when entering the spatialDataType production.
	EnterSpatialDataType(c *SpatialDataTypeContext)

	// EnterLongVarcharDataType is called when entering the longVarcharDataType production.
	EnterLongVarcharDataType(c *LongVarcharDataTypeContext)

	// EnterLongVarbinaryDataType is called when entering the longVarbinaryDataType production.
	EnterLongVarbinaryDataType(c *LongVarbinaryDataTypeContext)

	// EnterCollectionOptions is called when entering the collectionOptions production.
	EnterCollectionOptions(c *CollectionOptionsContext)

	// EnterConvertedDataType is called when entering the convertedDataType production.
	EnterConvertedDataType(c *ConvertedDataTypeContext)

	// EnterLengthOneDimension is called when entering the lengthOneDimension production.
	EnterLengthOneDimension(c *LengthOneDimensionContext)

	// EnterLengthTwoDimension is called when entering the lengthTwoDimension production.
	EnterLengthTwoDimension(c *LengthTwoDimensionContext)

	// EnterLengthTwoOptionalDimension is called when entering the lengthTwoOptionalDimension production.
	EnterLengthTwoOptionalDimension(c *LengthTwoOptionalDimensionContext)

	// EnterUidList is called when entering the uidList production.
	EnterUidList(c *UidListContext)

	// EnterUidWithNestings is called when entering the uidWithNestings production.
	EnterUidWithNestings(c *UidWithNestingsContext)

	// EnterUidListWithNestingsInParens is called when entering the uidListWithNestingsInParens production.
	EnterUidListWithNestingsInParens(c *UidListWithNestingsInParensContext)

	// EnterUidListWithNestings is called when entering the uidListWithNestings production.
	EnterUidListWithNestings(c *UidListWithNestingsContext)

	// EnterTables is called when entering the tables production.
	EnterTables(c *TablesContext)

	// EnterIndexColumnNames is called when entering the indexColumnNames production.
	EnterIndexColumnNames(c *IndexColumnNamesContext)

	// EnterExpressions is called when entering the expressions production.
	EnterExpressions(c *ExpressionsContext)

	// EnterExpressionsWithDefaults is called when entering the expressionsWithDefaults production.
	EnterExpressionsWithDefaults(c *ExpressionsWithDefaultsContext)

	// EnterRecordConstructorForInsert is called when entering the recordConstructorForInsert production.
	EnterRecordConstructorForInsert(c *RecordConstructorForInsertContext)

	// EnterRecordConstructorForInlineTable is called when entering the recordConstructorForInlineTable production.
	EnterRecordConstructorForInlineTable(c *RecordConstructorForInlineTableContext)

	// EnterRecordConstructor is called when entering the recordConstructor production.
	EnterRecordConstructor(c *RecordConstructorContext)

	// EnterOfTypeClause is called when entering the ofTypeClause production.
	EnterOfTypeClause(c *OfTypeClauseContext)

	// EnterArrayConstructor is called when entering the arrayConstructor production.
	EnterArrayConstructor(c *ArrayConstructorContext)

	// EnterUserVariables is called when entering the userVariables production.
	EnterUserVariables(c *UserVariablesContext)

	// EnterDefaultValue is called when entering the defaultValue production.
	EnterDefaultValue(c *DefaultValueContext)

	// EnterCurrentTimestamp is called when entering the currentTimestamp production.
	EnterCurrentTimestamp(c *CurrentTimestampContext)

	// EnterExpressionOrDefault is called when entering the expressionOrDefault production.
	EnterExpressionOrDefault(c *ExpressionOrDefaultContext)

	// EnterExpressionWithOptionalName is called when entering the expressionWithOptionalName production.
	EnterExpressionWithOptionalName(c *ExpressionWithOptionalNameContext)

	// EnterIfExists is called when entering the ifExists production.
	EnterIfExists(c *IfExistsContext)

	// EnterIfNotExists is called when entering the ifNotExists production.
	EnterIfNotExists(c *IfNotExistsContext)

	// EnterAggregateFunctionCall is called when entering the aggregateFunctionCall production.
	EnterAggregateFunctionCall(c *AggregateFunctionCallContext)

	// EnterNonAggregateFunctionCall is called when entering the nonAggregateFunctionCall production.
	EnterNonAggregateFunctionCall(c *NonAggregateFunctionCallContext)

	// EnterSpecificFunctionCall is called when entering the specificFunctionCall production.
	EnterSpecificFunctionCall(c *SpecificFunctionCallContext)

	// EnterScalarFunctionCall is called when entering the scalarFunctionCall production.
	EnterScalarFunctionCall(c *ScalarFunctionCallContext)

	// EnterUserDefinedScalarFunctionCall is called when entering the userDefinedScalarFunctionCall production.
	EnterUserDefinedScalarFunctionCall(c *UserDefinedScalarFunctionCallContext)

	// EnterSimpleFunctionCall is called when entering the simpleFunctionCall production.
	EnterSimpleFunctionCall(c *SimpleFunctionCallContext)

	// EnterDataTypeFunctionCall is called when entering the dataTypeFunctionCall production.
	EnterDataTypeFunctionCall(c *DataTypeFunctionCallContext)

	// EnterValuesFunctionCall is called when entering the valuesFunctionCall production.
	EnterValuesFunctionCall(c *ValuesFunctionCallContext)

	// EnterCaseExpressionFunctionCall is called when entering the caseExpressionFunctionCall production.
	EnterCaseExpressionFunctionCall(c *CaseExpressionFunctionCallContext)

	// EnterCaseFunctionCall is called when entering the caseFunctionCall production.
	EnterCaseFunctionCall(c *CaseFunctionCallContext)

	// EnterCharFunctionCall is called when entering the charFunctionCall production.
	EnterCharFunctionCall(c *CharFunctionCallContext)

	// EnterPositionFunctionCall is called when entering the positionFunctionCall production.
	EnterPositionFunctionCall(c *PositionFunctionCallContext)

	// EnterSubstrFunctionCall is called when entering the substrFunctionCall production.
	EnterSubstrFunctionCall(c *SubstrFunctionCallContext)

	// EnterTrimFunctionCall is called when entering the trimFunctionCall production.
	EnterTrimFunctionCall(c *TrimFunctionCallContext)

	// EnterWeightFunctionCall is called when entering the weightFunctionCall production.
	EnterWeightFunctionCall(c *WeightFunctionCallContext)

	// EnterExtractFunctionCall is called when entering the extractFunctionCall production.
	EnterExtractFunctionCall(c *ExtractFunctionCallContext)

	// EnterGetFormatFunctionCall is called when entering the getFormatFunctionCall production.
	EnterGetFormatFunctionCall(c *GetFormatFunctionCallContext)

	// EnterCaseFuncAlternative is called when entering the caseFuncAlternative production.
	EnterCaseFuncAlternative(c *CaseFuncAlternativeContext)

	// EnterLevelWeightList is called when entering the levelWeightList production.
	EnterLevelWeightList(c *LevelWeightListContext)

	// EnterLevelWeightRange is called when entering the levelWeightRange production.
	EnterLevelWeightRange(c *LevelWeightRangeContext)

	// EnterLevelInWeightListElement is called when entering the levelInWeightListElement production.
	EnterLevelInWeightListElement(c *LevelInWeightListElementContext)

	// EnterAggregateWindowedFunction is called when entering the aggregateWindowedFunction production.
	EnterAggregateWindowedFunction(c *AggregateWindowedFunctionContext)

	// EnterNullTreatmentClause is called when entering the nullTreatmentClause production.
	EnterNullTreatmentClause(c *NullTreatmentClauseContext)

	// EnterAggregateLimitClause is called when entering the aggregateLimitClause production.
	EnterAggregateLimitClause(c *AggregateLimitClauseContext)

	// EnterNonAggregateWindowedFunction is called when entering the nonAggregateWindowedFunction production.
	EnterNonAggregateWindowedFunction(c *NonAggregateWindowedFunctionContext)

	// EnterOverClause is called when entering the overClause production.
	EnterOverClause(c *OverClauseContext)

	// EnterWindowName is called when entering the windowName production.
	EnterWindowName(c *WindowNameContext)

	// EnterWindowSpec is called when entering the windowSpec production.
	EnterWindowSpec(c *WindowSpecContext)

	// EnterWindowOptionsClause is called when entering the windowOptionsClause production.
	EnterWindowOptionsClause(c *WindowOptionsClauseContext)

	// EnterWindowOption is called when entering the windowOption production.
	EnterWindowOption(c *WindowOptionContext)

	// EnterPartitionClause is called when entering the partitionClause production.
	EnterPartitionClause(c *PartitionClauseContext)

	// EnterScalarFunctionName is called when entering the scalarFunctionName production.
	EnterScalarFunctionName(c *ScalarFunctionNameContext)

	// EnterUserDefinedScalarFunctionName is called when entering the userDefinedScalarFunctionName production.
	EnterUserDefinedScalarFunctionName(c *UserDefinedScalarFunctionNameContext)

	// EnterFunctionArgs is called when entering the functionArgs production.
	EnterFunctionArgs(c *FunctionArgsContext)

	// EnterFunctionArg is called when entering the functionArg production.
	EnterFunctionArg(c *FunctionArgContext)

	// EnterNamedFunctionArg is called when entering the namedFunctionArg production.
	EnterNamedFunctionArg(c *NamedFunctionArgContext)

	// EnterPredicatedExpression is called when entering the predicatedExpression production.
	EnterPredicatedExpression(c *PredicatedExpressionContext)

	// EnterNotExpression is called when entering the notExpression production.
	EnterNotExpression(c *NotExpressionContext)

	// EnterLogicalExpression is called when entering the logicalExpression production.
	EnterLogicalExpression(c *LogicalExpressionContext)

	// EnterExistsExpressionAtom is called when entering the existsExpressionAtom production.
	EnterExistsExpressionAtom(c *ExistsExpressionAtomContext)

	// EnterBetweenComparisonPredicate is called when entering the betweenComparisonPredicate production.
	EnterBetweenComparisonPredicate(c *BetweenComparisonPredicateContext)

	// EnterInPredicate is called when entering the inPredicate production.
	EnterInPredicate(c *InPredicateContext)

	// EnterLikePredicate is called when entering the likePredicate production.
	EnterLikePredicate(c *LikePredicateContext)

	// EnterIsExpression is called when entering the isExpression production.
	EnterIsExpression(c *IsExpressionContext)

	// EnterSubqueryExpressionAtom is called when entering the subqueryExpressionAtom production.
	EnterSubqueryExpressionAtom(c *SubqueryExpressionAtomContext)

	// EnterBinaryComparisonPredicate is called when entering the binaryComparisonPredicate production.
	EnterBinaryComparisonPredicate(c *BinaryComparisonPredicateContext)

	// EnterSubscriptExpression is called when entering the subscriptExpression production.
	EnterSubscriptExpression(c *SubscriptExpressionContext)

	// EnterConstantExpressionAtom is called when entering the constantExpressionAtom production.
	EnterConstantExpressionAtom(c *ConstantExpressionAtomContext)

	// EnterFunctionCallExpressionAtom is called when entering the functionCallExpressionAtom production.
	EnterFunctionCallExpressionAtom(c *FunctionCallExpressionAtomContext)

	// EnterFullColumnNameExpressionAtom is called when entering the fullColumnNameExpressionAtom production.
	EnterFullColumnNameExpressionAtom(c *FullColumnNameExpressionAtomContext)

	// EnterBitExpressionAtom is called when entering the bitExpressionAtom production.
	EnterBitExpressionAtom(c *BitExpressionAtomContext)

	// EnterPreparedStatementParameterAtom is called when entering the preparedStatementParameterAtom production.
	EnterPreparedStatementParameterAtom(c *PreparedStatementParameterAtomContext)

	// EnterRecordConstructorExpressionAtom is called when entering the recordConstructorExpressionAtom production.
	EnterRecordConstructorExpressionAtom(c *RecordConstructorExpressionAtomContext)

	// EnterArrayConstructorExpressionAtom is called when entering the arrayConstructorExpressionAtom production.
	EnterArrayConstructorExpressionAtom(c *ArrayConstructorExpressionAtomContext)

	// EnterMathExpressionAtom is called when entering the mathExpressionAtom production.
	EnterMathExpressionAtom(c *MathExpressionAtomContext)

	// EnterInList is called when entering the inList production.
	EnterInList(c *InListContext)

	// EnterPreparedStatementParameter is called when entering the preparedStatementParameter production.
	EnterPreparedStatementParameter(c *PreparedStatementParameterContext)

	// EnterUnaryOperator is called when entering the unaryOperator production.
	EnterUnaryOperator(c *UnaryOperatorContext)

	// EnterComparisonOperator is called when entering the comparisonOperator production.
	EnterComparisonOperator(c *ComparisonOperatorContext)

	// EnterLogicalOperator is called when entering the logicalOperator production.
	EnterLogicalOperator(c *LogicalOperatorContext)

	// EnterBitOperator is called when entering the bitOperator production.
	EnterBitOperator(c *BitOperatorContext)

	// EnterMathOperator is called when entering the mathOperator production.
	EnterMathOperator(c *MathOperatorContext)

	// EnterJsonOperator is called when entering the jsonOperator production.
	EnterJsonOperator(c *JsonOperatorContext)

	// EnterCharsetNameBase is called when entering the charsetNameBase production.
	EnterCharsetNameBase(c *CharsetNameBaseContext)

	// EnterIntervalTypeBase is called when entering the intervalTypeBase production.
	EnterIntervalTypeBase(c *IntervalTypeBaseContext)

	// EnterKeywordsCanBeId is called when entering the keywordsCanBeId production.
	EnterKeywordsCanBeId(c *KeywordsCanBeIdContext)

	// EnterFunctionNameBase is called when entering the functionNameBase production.
	EnterFunctionNameBase(c *FunctionNameBaseContext)

	// EnterFunctionNameKeyword is called when entering the functionNameKeyword production.
	EnterFunctionNameKeyword(c *FunctionNameKeywordContext)

	// ExitRoot is called when exiting the root production.
	ExitRoot(c *RootContext)

	// ExitStatements is called when exiting the statements production.
	ExitStatements(c *StatementsContext)

	// ExitStatement is called when exiting the statement production.
	ExitStatement(c *StatementContext)

	// ExitDmlStatement is called when exiting the dmlStatement production.
	ExitDmlStatement(c *DmlStatementContext)

	// ExitDdlStatement is called when exiting the ddlStatement production.
	ExitDdlStatement(c *DdlStatementContext)

	// ExitTransactionStatement is called when exiting the transactionStatement production.
	ExitTransactionStatement(c *TransactionStatementContext)

	// ExitPreparedStatement is called when exiting the preparedStatement production.
	ExitPreparedStatement(c *PreparedStatementContext)

	// ExitAdministrationStatement is called when exiting the administrationStatement production.
	ExitAdministrationStatement(c *AdministrationStatementContext)

	// ExitUtilityStatement is called when exiting the utilityStatement production.
	ExitUtilityStatement(c *UtilityStatementContext)

	// ExitTemplateClause is called when exiting the templateClause production.
	ExitTemplateClause(c *TemplateClauseContext)

	// ExitCreateSchemaStatement is called when exiting the createSchemaStatement production.
	ExitCreateSchemaStatement(c *CreateSchemaStatementContext)

	// ExitCreateSchemaTemplateStatement is called when exiting the createSchemaTemplateStatement production.
	ExitCreateSchemaTemplateStatement(c *CreateSchemaTemplateStatementContext)

	// ExitCreateDatabaseStatement is called when exiting the createDatabaseStatement production.
	ExitCreateDatabaseStatement(c *CreateDatabaseStatementContext)

	// ExitOptionsClause is called when exiting the optionsClause production.
	ExitOptionsClause(c *OptionsClauseContext)

	// ExitOption is called when exiting the option production.
	ExitOption(c *OptionContext)

	// ExitDropDatabaseStatement is called when exiting the dropDatabaseStatement production.
	ExitDropDatabaseStatement(c *DropDatabaseStatementContext)

	// ExitDropSchemaTemplateStatement is called when exiting the dropSchemaTemplateStatement production.
	ExitDropSchemaTemplateStatement(c *DropSchemaTemplateStatementContext)

	// ExitDropSchemaStatement is called when exiting the dropSchemaStatement production.
	ExitDropSchemaStatement(c *DropSchemaStatementContext)

	// ExitStructDefinition is called when exiting the structDefinition production.
	ExitStructDefinition(c *StructDefinitionContext)

	// ExitTableDefinition is called when exiting the tableDefinition production.
	ExitTableDefinition(c *TableDefinitionContext)

	// ExitColumnDefinition is called when exiting the columnDefinition production.
	ExitColumnDefinition(c *ColumnDefinitionContext)

	// ExitFunctionColumnType is called when exiting the functionColumnType production.
	ExitFunctionColumnType(c *FunctionColumnTypeContext)

	// ExitColumnType is called when exiting the columnType production.
	ExitColumnType(c *ColumnTypeContext)

	// ExitPrimitiveType is called when exiting the primitiveType production.
	ExitPrimitiveType(c *PrimitiveTypeContext)

	// ExitVectorType is called when exiting the vectorType production.
	ExitVectorType(c *VectorTypeContext)

	// ExitVectorElementType is called when exiting the vectorElementType production.
	ExitVectorElementType(c *VectorElementTypeContext)

	// ExitNullColumnConstraint is called when exiting the nullColumnConstraint production.
	ExitNullColumnConstraint(c *NullColumnConstraintContext)

	// ExitPrimaryKeyDefinition is called when exiting the primaryKeyDefinition production.
	ExitPrimaryKeyDefinition(c *PrimaryKeyDefinitionContext)

	// ExitFullIdList is called when exiting the fullIdList production.
	ExitFullIdList(c *FullIdListContext)

	// ExitEnumDefinition is called when exiting the enumDefinition production.
	ExitEnumDefinition(c *EnumDefinitionContext)

	// ExitIndexAsSelectDefinition is called when exiting the indexAsSelectDefinition production.
	ExitIndexAsSelectDefinition(c *IndexAsSelectDefinitionContext)

	// ExitIndexOnSourceDefinition is called when exiting the indexOnSourceDefinition production.
	ExitIndexOnSourceDefinition(c *IndexOnSourceDefinitionContext)

	// ExitVectorIndexDefinition is called when exiting the vectorIndexDefinition production.
	ExitVectorIndexDefinition(c *VectorIndexDefinitionContext)

	// ExitVectorEngine is called when exiting the vectorEngine production.
	ExitVectorEngine(c *VectorEngineContext)

	// ExitIndexColumnList is called when exiting the indexColumnList production.
	ExitIndexColumnList(c *IndexColumnListContext)

	// ExitIndexColumnSpec is called when exiting the indexColumnSpec production.
	ExitIndexColumnSpec(c *IndexColumnSpecContext)

	// ExitIncludeClause is called when exiting the includeClause production.
	ExitIncludeClause(c *IncludeClauseContext)

	// ExitIndexType is called when exiting the indexType production.
	ExitIndexType(c *IndexTypeContext)

	// ExitIndexPartitionClause is called when exiting the indexPartitionClause production.
	ExitIndexPartitionClause(c *IndexPartitionClauseContext)

	// ExitIndexOptions is called when exiting the indexOptions production.
	ExitIndexOptions(c *IndexOptionsContext)

	// ExitIndexOption is called when exiting the indexOption production.
	ExitIndexOption(c *IndexOptionContext)

	// ExitVectorIndexOptions is called when exiting the vectorIndexOptions production.
	ExitVectorIndexOptions(c *VectorIndexOptionsContext)

	// ExitVectorIndexOption is called when exiting the vectorIndexOption production.
	ExitVectorIndexOption(c *VectorIndexOptionContext)

	// ExitVectorIndexOptionValue is called when exiting the vectorIndexOptionValue production.
	ExitVectorIndexOptionValue(c *VectorIndexOptionValueContext)

	// ExitHnswMetric is called when exiting the hnswMetric production.
	ExitHnswMetric(c *HnswMetricContext)

	// ExitIndexAttributes is called when exiting the indexAttributes production.
	ExitIndexAttributes(c *IndexAttributesContext)

	// ExitIndexAttribute is called when exiting the indexAttribute production.
	ExitIndexAttribute(c *IndexAttributeContext)

	// ExitCreateTempFunction is called when exiting the createTempFunction production.
	ExitCreateTempFunction(c *CreateTempFunctionContext)

	// ExitDropTempFunction is called when exiting the dropTempFunction production.
	ExitDropTempFunction(c *DropTempFunctionContext)

	// ExitViewDefinition is called when exiting the viewDefinition production.
	ExitViewDefinition(c *ViewDefinitionContext)

	// ExitStoredQueryDefinition is called when exiting the storedQueryDefinition production.
	ExitStoredQueryDefinition(c *StoredQueryDefinitionContext)

	// ExitDeclareBlock is called when exiting the declareBlock production.
	ExitDeclareBlock(c *DeclareBlockContext)

	// ExitDeclaredFunction is called when exiting the declaredFunction production.
	ExitDeclaredFunction(c *DeclaredFunctionContext)

	// ExitTempSqlInvokedFunction is called when exiting the tempSqlInvokedFunction production.
	ExitTempSqlInvokedFunction(c *TempSqlInvokedFunctionContext)

	// ExitSqlInvokedFunction is called when exiting the sqlInvokedFunction production.
	ExitSqlInvokedFunction(c *SqlInvokedFunctionContext)

	// ExitFunctionSpecification is called when exiting the functionSpecification production.
	ExitFunctionSpecification(c *FunctionSpecificationContext)

	// ExitSqlParameterDeclarationList is called when exiting the sqlParameterDeclarationList production.
	ExitSqlParameterDeclarationList(c *SqlParameterDeclarationListContext)

	// ExitSqlParameterDeclarations is called when exiting the sqlParameterDeclarations production.
	ExitSqlParameterDeclarations(c *SqlParameterDeclarationsContext)

	// ExitSqlParameterDeclaration is called when exiting the sqlParameterDeclaration production.
	ExitSqlParameterDeclaration(c *SqlParameterDeclarationContext)

	// ExitParameterMode is called when exiting the parameterMode production.
	ExitParameterMode(c *ParameterModeContext)

	// ExitReturnsClause is called when exiting the returnsClause production.
	ExitReturnsClause(c *ReturnsClauseContext)

	// ExitReturnsType is called when exiting the returnsType production.
	ExitReturnsType(c *ReturnsTypeContext)

	// ExitReturnsTableType is called when exiting the returnsTableType production.
	ExitReturnsTableType(c *ReturnsTableTypeContext)

	// ExitTableFunctionColumnList is called when exiting the tableFunctionColumnList production.
	ExitTableFunctionColumnList(c *TableFunctionColumnListContext)

	// ExitTableFunctionColumnListElement is called when exiting the tableFunctionColumnListElement production.
	ExitTableFunctionColumnListElement(c *TableFunctionColumnListElementContext)

	// ExitRoutineCharacteristics is called when exiting the routineCharacteristics production.
	ExitRoutineCharacteristics(c *RoutineCharacteristicsContext)

	// ExitLanguageClause is called when exiting the languageClause production.
	ExitLanguageClause(c *LanguageClauseContext)

	// ExitLanguageName is called when exiting the languageName production.
	ExitLanguageName(c *LanguageNameContext)

	// ExitParameterStyle is called when exiting the parameterStyle production.
	ExitParameterStyle(c *ParameterStyleContext)

	// ExitDeterministicCharacteristic is called when exiting the deterministicCharacteristic production.
	ExitDeterministicCharacteristic(c *DeterministicCharacteristicContext)

	// ExitNullCallClause is called when exiting the nullCallClause production.
	ExitNullCallClause(c *NullCallClauseContext)

	// ExitDispatchClause is called when exiting the dispatchClause production.
	ExitDispatchClause(c *DispatchClauseContext)

	// ExitStatementBody is called when exiting the statementBody production.
	ExitStatementBody(c *StatementBodyContext)

	// ExitUserDefinedMacroFunctionStatementBody is called when exiting the userDefinedMacroFunctionStatementBody production.
	ExitUserDefinedMacroFunctionStatementBody(c *UserDefinedMacroFunctionStatementBodyContext)

	// ExitCharSet is called when exiting the charSet production.
	ExitCharSet(c *CharSetContext)

	// ExitIntervalType is called when exiting the intervalType production.
	ExitIntervalType(c *IntervalTypeContext)

	// ExitSchemaId is called when exiting the schemaId production.
	ExitSchemaId(c *SchemaIdContext)

	// ExitPath is called when exiting the path production.
	ExitPath(c *PathContext)

	// ExitSchemaTemplateId is called when exiting the schemaTemplateId production.
	ExitSchemaTemplateId(c *SchemaTemplateIdContext)

	// ExitDeleteStatement is called when exiting the deleteStatement production.
	ExitDeleteStatement(c *DeleteStatementContext)

	// ExitInsertStatement is called when exiting the insertStatement production.
	ExitInsertStatement(c *InsertStatementContext)

	// ExitContinuationAtom is called when exiting the continuationAtom production.
	ExitContinuationAtom(c *ContinuationAtomContext)

	// ExitSelectStatement is called when exiting the selectStatement production.
	ExitSelectStatement(c *SelectStatementContext)

	// ExitQuery is called when exiting the query production.
	ExitQuery(c *QueryContext)

	// ExitCtes is called when exiting the ctes production.
	ExitCtes(c *CtesContext)

	// ExitTraversalOrderClause is called when exiting the traversalOrderClause production.
	ExitTraversalOrderClause(c *TraversalOrderClauseContext)

	// ExitNamedQuery is called when exiting the namedQuery production.
	ExitNamedQuery(c *NamedQueryContext)

	// ExitTableFunction is called when exiting the tableFunction production.
	ExitTableFunction(c *TableFunctionContext)

	// ExitNamedOrUnnamedFunctionArgs is called when exiting the namedOrUnnamedFunctionArgs production.
	ExitNamedOrUnnamedFunctionArgs(c *NamedOrUnnamedFunctionArgsContext)

	// ExitTableFunctionName is called when exiting the tableFunctionName production.
	ExitTableFunctionName(c *TableFunctionNameContext)

	// ExitQueryTermDefault is called when exiting the queryTermDefault production.
	ExitQueryTermDefault(c *QueryTermDefaultContext)

	// ExitSetQuery is called when exiting the setQuery production.
	ExitSetQuery(c *SetQueryContext)

	// ExitInsertStatementValueSelect is called when exiting the insertStatementValueSelect production.
	ExitInsertStatementValueSelect(c *InsertStatementValueSelectContext)

	// ExitInsertStatementValueValues is called when exiting the insertStatementValueValues production.
	ExitInsertStatementValueValues(c *InsertStatementValueValuesContext)

	// ExitUpdatedElement is called when exiting the updatedElement production.
	ExitUpdatedElement(c *UpdatedElementContext)

	// ExitAssignmentField is called when exiting the assignmentField production.
	ExitAssignmentField(c *AssignmentFieldContext)

	// ExitUpdateStatement is called when exiting the updateStatement production.
	ExitUpdateStatement(c *UpdateStatementContext)

	// ExitOrderByClause is called when exiting the orderByClause production.
	ExitOrderByClause(c *OrderByClauseContext)

	// ExitOrderByExpression is called when exiting the orderByExpression production.
	ExitOrderByExpression(c *OrderByExpressionContext)

	// ExitOrderClause is called when exiting the orderClause production.
	ExitOrderClause(c *OrderClauseContext)

	// ExitTableSources is called when exiting the tableSources production.
	ExitTableSources(c *TableSourcesContext)

	// ExitTableSourceBase is called when exiting the tableSourceBase production.
	ExitTableSourceBase(c *TableSourceBaseContext)

	// ExitAtomTableItem is called when exiting the atomTableItem production.
	ExitAtomTableItem(c *AtomTableItemContext)

	// ExitSubqueryTableItem is called when exiting the subqueryTableItem production.
	ExitSubqueryTableItem(c *SubqueryTableItemContext)

	// ExitInlineTableItem is called when exiting the inlineTableItem production.
	ExitInlineTableItem(c *InlineTableItemContext)

	// ExitTableValuedFunction is called when exiting the tableValuedFunction production.
	ExitTableValuedFunction(c *TableValuedFunctionContext)

	// ExitIndexHint is called when exiting the indexHint production.
	ExitIndexHint(c *IndexHintContext)

	// ExitIndexHintType is called when exiting the indexHintType production.
	ExitIndexHintType(c *IndexHintTypeContext)

	// ExitInlineTableDefinition is called when exiting the inlineTableDefinition production.
	ExitInlineTableDefinition(c *InlineTableDefinitionContext)

	// ExitInnerJoin is called when exiting the innerJoin production.
	ExitInnerJoin(c *InnerJoinContext)

	// ExitStraightJoin is called when exiting the straightJoin production.
	ExitStraightJoin(c *StraightJoinContext)

	// ExitOuterJoin is called when exiting the outerJoin production.
	ExitOuterJoin(c *OuterJoinContext)

	// ExitNaturalJoin is called when exiting the naturalJoin production.
	ExitNaturalJoin(c *NaturalJoinContext)

	// ExitSimpleTable is called when exiting the simpleTable production.
	ExitSimpleTable(c *SimpleTableContext)

	// ExitParenthesisQuery is called when exiting the parenthesisQuery production.
	ExitParenthesisQuery(c *ParenthesisQueryContext)

	// ExitSelectElements is called when exiting the selectElements production.
	ExitSelectElements(c *SelectElementsContext)

	// ExitSelectStarElement is called when exiting the selectStarElement production.
	ExitSelectStarElement(c *SelectStarElementContext)

	// ExitSelectQualifierStarElement is called when exiting the selectQualifierStarElement production.
	ExitSelectQualifierStarElement(c *SelectQualifierStarElementContext)

	// ExitSelectExpressionElement is called when exiting the selectExpressionElement production.
	ExitSelectExpressionElement(c *SelectExpressionElementContext)

	// ExitFromClause is called when exiting the fromClause production.
	ExitFromClause(c *FromClauseContext)

	// ExitGroupByClause is called when exiting the groupByClause production.
	ExitGroupByClause(c *GroupByClauseContext)

	// ExitWhereExpr is called when exiting the whereExpr production.
	ExitWhereExpr(c *WhereExprContext)

	// ExitHavingClause is called when exiting the havingClause production.
	ExitHavingClause(c *HavingClauseContext)

	// ExitQualifyClause is called when exiting the qualifyClause production.
	ExitQualifyClause(c *QualifyClauseContext)

	// ExitGroupByItem is called when exiting the groupByItem production.
	ExitGroupByItem(c *GroupByItemContext)

	// ExitLimitClause is called when exiting the limitClause production.
	ExitLimitClause(c *LimitClauseContext)

	// ExitLimitClauseAtom is called when exiting the limitClauseAtom production.
	ExitLimitClauseAtom(c *LimitClauseAtomContext)

	// ExitStatementOptions is called when exiting the statementOptions production.
	ExitStatementOptions(c *StatementOptionsContext)

	// ExitStatementOption is called when exiting the statementOption production.
	ExitStatementOption(c *StatementOptionContext)

	// ExitStartTransaction is called when exiting the startTransaction production.
	ExitStartTransaction(c *StartTransactionContext)

	// ExitCommitStatement is called when exiting the commitStatement production.
	ExitCommitStatement(c *CommitStatementContext)

	// ExitRollbackStatement is called when exiting the rollbackStatement production.
	ExitRollbackStatement(c *RollbackStatementContext)

	// ExitSetAutocommitStatement is called when exiting the setAutocommitStatement production.
	ExitSetAutocommitStatement(c *SetAutocommitStatementContext)

	// ExitSetTransactionStatement is called when exiting the setTransactionStatement production.
	ExitSetTransactionStatement(c *SetTransactionStatementContext)

	// ExitTransactionOption is called when exiting the transactionOption production.
	ExitTransactionOption(c *TransactionOptionContext)

	// ExitTransactionLevel is called when exiting the transactionLevel production.
	ExitTransactionLevel(c *TransactionLevelContext)

	// ExitPrepareStatement is called when exiting the prepareStatement production.
	ExitPrepareStatement(c *PrepareStatementContext)

	// ExitExecuteStatement is called when exiting the executeStatement production.
	ExitExecuteStatement(c *ExecuteStatementContext)

	// ExitShowDatabasesStatement is called when exiting the showDatabasesStatement production.
	ExitShowDatabasesStatement(c *ShowDatabasesStatementContext)

	// ExitShowSchemaTemplatesStatement is called when exiting the showSchemaTemplatesStatement production.
	ExitShowSchemaTemplatesStatement(c *ShowSchemaTemplatesStatementContext)

	// ExitSetVariable is called when exiting the setVariable production.
	ExitSetVariable(c *SetVariableContext)

	// ExitSetCharset is called when exiting the setCharset production.
	ExitSetCharset(c *SetCharsetContext)

	// ExitSetNames is called when exiting the setNames production.
	ExitSetNames(c *SetNamesContext)

	// ExitSetTransaction is called when exiting the setTransaction production.
	ExitSetTransaction(c *SetTransactionContext)

	// ExitSetAutocommit is called when exiting the setAutocommit production.
	ExitSetAutocommit(c *SetAutocommitContext)

	// ExitSetNewValueInsideTrigger is called when exiting the setNewValueInsideTrigger production.
	ExitSetNewValueInsideTrigger(c *SetNewValueInsideTriggerContext)

	// ExitVariableClause is called when exiting the variableClause production.
	ExitVariableClause(c *VariableClauseContext)

	// ExitKillStatement is called when exiting the killStatement production.
	ExitKillStatement(c *KillStatementContext)

	// ExitResetStatement is called when exiting the resetStatement production.
	ExitResetStatement(c *ResetStatementContext)

	// ExitExecuteContinuationStatement is called when exiting the executeContinuationStatement production.
	ExitExecuteContinuationStatement(c *ExecuteContinuationStatementContext)

	// ExitCopyExportStatement is called when exiting the copyExportStatement production.
	ExitCopyExportStatement(c *CopyExportStatementContext)

	// ExitCopyImportStatement is called when exiting the copyImportStatement production.
	ExitCopyImportStatement(c *CopyImportStatementContext)

	// ExitTableIndexes is called when exiting the tableIndexes production.
	ExitTableIndexes(c *TableIndexesContext)

	// ExitLoadedTableIndexes is called when exiting the loadedTableIndexes production.
	ExitLoadedTableIndexes(c *LoadedTableIndexesContext)

	// ExitSimpleDescribeSchemaStatement is called when exiting the simpleDescribeSchemaStatement production.
	ExitSimpleDescribeSchemaStatement(c *SimpleDescribeSchemaStatementContext)

	// ExitSimpleDescribeSchemaTemplateStatement is called when exiting the simpleDescribeSchemaTemplateStatement production.
	ExitSimpleDescribeSchemaTemplateStatement(c *SimpleDescribeSchemaTemplateStatementContext)

	// ExitFullDescribeStatement is called when exiting the fullDescribeStatement production.
	ExitFullDescribeStatement(c *FullDescribeStatementContext)

	// ExitHelpStatement is called when exiting the helpStatement production.
	ExitHelpStatement(c *HelpStatementContext)

	// ExitDescribeStatements is called when exiting the describeStatements production.
	ExitDescribeStatements(c *DescribeStatementsContext)

	// ExitDescribeConnection is called when exiting the describeConnection production.
	ExitDescribeConnection(c *DescribeConnectionContext)

	// ExitFullId is called when exiting the fullId production.
	ExitFullId(c *FullIdContext)

	// ExitTableName is called when exiting the tableName production.
	ExitTableName(c *TableNameContext)

	// ExitFullColumnName is called when exiting the fullColumnName production.
	ExitFullColumnName(c *FullColumnNameContext)

	// ExitIndexColumnName is called when exiting the indexColumnName production.
	ExitIndexColumnName(c *IndexColumnNameContext)

	// ExitCharsetName is called when exiting the charsetName production.
	ExitCharsetName(c *CharsetNameContext)

	// ExitCollationName is called when exiting the collationName production.
	ExitCollationName(c *CollationNameContext)

	// ExitUid is called when exiting the uid production.
	ExitUid(c *UidContext)

	// ExitSimpleId is called when exiting the simpleId production.
	ExitSimpleId(c *SimpleIdContext)

	// ExitNullNotnull is called when exiting the nullNotnull production.
	ExitNullNotnull(c *NullNotnullContext)

	// ExitDecimalLiteral is called when exiting the decimalLiteral production.
	ExitDecimalLiteral(c *DecimalLiteralContext)

	// ExitStringLiteral is called when exiting the stringLiteral production.
	ExitStringLiteral(c *StringLiteralContext)

	// ExitBooleanLiteral is called when exiting the booleanLiteral production.
	ExitBooleanLiteral(c *BooleanLiteralContext)

	// ExitBytesLiteral is called when exiting the bytesLiteral production.
	ExitBytesLiteral(c *BytesLiteralContext)

	// ExitNullLiteral is called when exiting the nullLiteral production.
	ExitNullLiteral(c *NullLiteralContext)

	// ExitStringConstant is called when exiting the stringConstant production.
	ExitStringConstant(c *StringConstantContext)

	// ExitDecimalConstant is called when exiting the decimalConstant production.
	ExitDecimalConstant(c *DecimalConstantContext)

	// ExitNegativeDecimalConstant is called when exiting the negativeDecimalConstant production.
	ExitNegativeDecimalConstant(c *NegativeDecimalConstantContext)

	// ExitBytesConstant is called when exiting the bytesConstant production.
	ExitBytesConstant(c *BytesConstantContext)

	// ExitBooleanConstant is called when exiting the booleanConstant production.
	ExitBooleanConstant(c *BooleanConstantContext)

	// ExitBitStringConstant is called when exiting the bitStringConstant production.
	ExitBitStringConstant(c *BitStringConstantContext)

	// ExitNullConstant is called when exiting the nullConstant production.
	ExitNullConstant(c *NullConstantContext)

	// ExitStringDataType is called when exiting the stringDataType production.
	ExitStringDataType(c *StringDataTypeContext)

	// ExitNationalStringDataType is called when exiting the nationalStringDataType production.
	ExitNationalStringDataType(c *NationalStringDataTypeContext)

	// ExitNationalVaryingStringDataType is called when exiting the nationalVaryingStringDataType production.
	ExitNationalVaryingStringDataType(c *NationalVaryingStringDataTypeContext)

	// ExitDimensionDataType is called when exiting the dimensionDataType production.
	ExitDimensionDataType(c *DimensionDataTypeContext)

	// ExitSimpleDataType is called when exiting the simpleDataType production.
	ExitSimpleDataType(c *SimpleDataTypeContext)

	// ExitCollectionDataType is called when exiting the collectionDataType production.
	ExitCollectionDataType(c *CollectionDataTypeContext)

	// ExitSpatialDataType is called when exiting the spatialDataType production.
	ExitSpatialDataType(c *SpatialDataTypeContext)

	// ExitLongVarcharDataType is called when exiting the longVarcharDataType production.
	ExitLongVarcharDataType(c *LongVarcharDataTypeContext)

	// ExitLongVarbinaryDataType is called when exiting the longVarbinaryDataType production.
	ExitLongVarbinaryDataType(c *LongVarbinaryDataTypeContext)

	// ExitCollectionOptions is called when exiting the collectionOptions production.
	ExitCollectionOptions(c *CollectionOptionsContext)

	// ExitConvertedDataType is called when exiting the convertedDataType production.
	ExitConvertedDataType(c *ConvertedDataTypeContext)

	// ExitLengthOneDimension is called when exiting the lengthOneDimension production.
	ExitLengthOneDimension(c *LengthOneDimensionContext)

	// ExitLengthTwoDimension is called when exiting the lengthTwoDimension production.
	ExitLengthTwoDimension(c *LengthTwoDimensionContext)

	// ExitLengthTwoOptionalDimension is called when exiting the lengthTwoOptionalDimension production.
	ExitLengthTwoOptionalDimension(c *LengthTwoOptionalDimensionContext)

	// ExitUidList is called when exiting the uidList production.
	ExitUidList(c *UidListContext)

	// ExitUidWithNestings is called when exiting the uidWithNestings production.
	ExitUidWithNestings(c *UidWithNestingsContext)

	// ExitUidListWithNestingsInParens is called when exiting the uidListWithNestingsInParens production.
	ExitUidListWithNestingsInParens(c *UidListWithNestingsInParensContext)

	// ExitUidListWithNestings is called when exiting the uidListWithNestings production.
	ExitUidListWithNestings(c *UidListWithNestingsContext)

	// ExitTables is called when exiting the tables production.
	ExitTables(c *TablesContext)

	// ExitIndexColumnNames is called when exiting the indexColumnNames production.
	ExitIndexColumnNames(c *IndexColumnNamesContext)

	// ExitExpressions is called when exiting the expressions production.
	ExitExpressions(c *ExpressionsContext)

	// ExitExpressionsWithDefaults is called when exiting the expressionsWithDefaults production.
	ExitExpressionsWithDefaults(c *ExpressionsWithDefaultsContext)

	// ExitRecordConstructorForInsert is called when exiting the recordConstructorForInsert production.
	ExitRecordConstructorForInsert(c *RecordConstructorForInsertContext)

	// ExitRecordConstructorForInlineTable is called when exiting the recordConstructorForInlineTable production.
	ExitRecordConstructorForInlineTable(c *RecordConstructorForInlineTableContext)

	// ExitRecordConstructor is called when exiting the recordConstructor production.
	ExitRecordConstructor(c *RecordConstructorContext)

	// ExitOfTypeClause is called when exiting the ofTypeClause production.
	ExitOfTypeClause(c *OfTypeClauseContext)

	// ExitArrayConstructor is called when exiting the arrayConstructor production.
	ExitArrayConstructor(c *ArrayConstructorContext)

	// ExitUserVariables is called when exiting the userVariables production.
	ExitUserVariables(c *UserVariablesContext)

	// ExitDefaultValue is called when exiting the defaultValue production.
	ExitDefaultValue(c *DefaultValueContext)

	// ExitCurrentTimestamp is called when exiting the currentTimestamp production.
	ExitCurrentTimestamp(c *CurrentTimestampContext)

	// ExitExpressionOrDefault is called when exiting the expressionOrDefault production.
	ExitExpressionOrDefault(c *ExpressionOrDefaultContext)

	// ExitExpressionWithOptionalName is called when exiting the expressionWithOptionalName production.
	ExitExpressionWithOptionalName(c *ExpressionWithOptionalNameContext)

	// ExitIfExists is called when exiting the ifExists production.
	ExitIfExists(c *IfExistsContext)

	// ExitIfNotExists is called when exiting the ifNotExists production.
	ExitIfNotExists(c *IfNotExistsContext)

	// ExitAggregateFunctionCall is called when exiting the aggregateFunctionCall production.
	ExitAggregateFunctionCall(c *AggregateFunctionCallContext)

	// ExitNonAggregateFunctionCall is called when exiting the nonAggregateFunctionCall production.
	ExitNonAggregateFunctionCall(c *NonAggregateFunctionCallContext)

	// ExitSpecificFunctionCall is called when exiting the specificFunctionCall production.
	ExitSpecificFunctionCall(c *SpecificFunctionCallContext)

	// ExitScalarFunctionCall is called when exiting the scalarFunctionCall production.
	ExitScalarFunctionCall(c *ScalarFunctionCallContext)

	// ExitUserDefinedScalarFunctionCall is called when exiting the userDefinedScalarFunctionCall production.
	ExitUserDefinedScalarFunctionCall(c *UserDefinedScalarFunctionCallContext)

	// ExitSimpleFunctionCall is called when exiting the simpleFunctionCall production.
	ExitSimpleFunctionCall(c *SimpleFunctionCallContext)

	// ExitDataTypeFunctionCall is called when exiting the dataTypeFunctionCall production.
	ExitDataTypeFunctionCall(c *DataTypeFunctionCallContext)

	// ExitValuesFunctionCall is called when exiting the valuesFunctionCall production.
	ExitValuesFunctionCall(c *ValuesFunctionCallContext)

	// ExitCaseExpressionFunctionCall is called when exiting the caseExpressionFunctionCall production.
	ExitCaseExpressionFunctionCall(c *CaseExpressionFunctionCallContext)

	// ExitCaseFunctionCall is called when exiting the caseFunctionCall production.
	ExitCaseFunctionCall(c *CaseFunctionCallContext)

	// ExitCharFunctionCall is called when exiting the charFunctionCall production.
	ExitCharFunctionCall(c *CharFunctionCallContext)

	// ExitPositionFunctionCall is called when exiting the positionFunctionCall production.
	ExitPositionFunctionCall(c *PositionFunctionCallContext)

	// ExitSubstrFunctionCall is called when exiting the substrFunctionCall production.
	ExitSubstrFunctionCall(c *SubstrFunctionCallContext)

	// ExitTrimFunctionCall is called when exiting the trimFunctionCall production.
	ExitTrimFunctionCall(c *TrimFunctionCallContext)

	// ExitWeightFunctionCall is called when exiting the weightFunctionCall production.
	ExitWeightFunctionCall(c *WeightFunctionCallContext)

	// ExitExtractFunctionCall is called when exiting the extractFunctionCall production.
	ExitExtractFunctionCall(c *ExtractFunctionCallContext)

	// ExitGetFormatFunctionCall is called when exiting the getFormatFunctionCall production.
	ExitGetFormatFunctionCall(c *GetFormatFunctionCallContext)

	// ExitCaseFuncAlternative is called when exiting the caseFuncAlternative production.
	ExitCaseFuncAlternative(c *CaseFuncAlternativeContext)

	// ExitLevelWeightList is called when exiting the levelWeightList production.
	ExitLevelWeightList(c *LevelWeightListContext)

	// ExitLevelWeightRange is called when exiting the levelWeightRange production.
	ExitLevelWeightRange(c *LevelWeightRangeContext)

	// ExitLevelInWeightListElement is called when exiting the levelInWeightListElement production.
	ExitLevelInWeightListElement(c *LevelInWeightListElementContext)

	// ExitAggregateWindowedFunction is called when exiting the aggregateWindowedFunction production.
	ExitAggregateWindowedFunction(c *AggregateWindowedFunctionContext)

	// ExitNullTreatmentClause is called when exiting the nullTreatmentClause production.
	ExitNullTreatmentClause(c *NullTreatmentClauseContext)

	// ExitAggregateLimitClause is called when exiting the aggregateLimitClause production.
	ExitAggregateLimitClause(c *AggregateLimitClauseContext)

	// ExitNonAggregateWindowedFunction is called when exiting the nonAggregateWindowedFunction production.
	ExitNonAggregateWindowedFunction(c *NonAggregateWindowedFunctionContext)

	// ExitOverClause is called when exiting the overClause production.
	ExitOverClause(c *OverClauseContext)

	// ExitWindowName is called when exiting the windowName production.
	ExitWindowName(c *WindowNameContext)

	// ExitWindowSpec is called when exiting the windowSpec production.
	ExitWindowSpec(c *WindowSpecContext)

	// ExitWindowOptionsClause is called when exiting the windowOptionsClause production.
	ExitWindowOptionsClause(c *WindowOptionsClauseContext)

	// ExitWindowOption is called when exiting the windowOption production.
	ExitWindowOption(c *WindowOptionContext)

	// ExitPartitionClause is called when exiting the partitionClause production.
	ExitPartitionClause(c *PartitionClauseContext)

	// ExitScalarFunctionName is called when exiting the scalarFunctionName production.
	ExitScalarFunctionName(c *ScalarFunctionNameContext)

	// ExitUserDefinedScalarFunctionName is called when exiting the userDefinedScalarFunctionName production.
	ExitUserDefinedScalarFunctionName(c *UserDefinedScalarFunctionNameContext)

	// ExitFunctionArgs is called when exiting the functionArgs production.
	ExitFunctionArgs(c *FunctionArgsContext)

	// ExitFunctionArg is called when exiting the functionArg production.
	ExitFunctionArg(c *FunctionArgContext)

	// ExitNamedFunctionArg is called when exiting the namedFunctionArg production.
	ExitNamedFunctionArg(c *NamedFunctionArgContext)

	// ExitPredicatedExpression is called when exiting the predicatedExpression production.
	ExitPredicatedExpression(c *PredicatedExpressionContext)

	// ExitNotExpression is called when exiting the notExpression production.
	ExitNotExpression(c *NotExpressionContext)

	// ExitLogicalExpression is called when exiting the logicalExpression production.
	ExitLogicalExpression(c *LogicalExpressionContext)

	// ExitExistsExpressionAtom is called when exiting the existsExpressionAtom production.
	ExitExistsExpressionAtom(c *ExistsExpressionAtomContext)

	// ExitBetweenComparisonPredicate is called when exiting the betweenComparisonPredicate production.
	ExitBetweenComparisonPredicate(c *BetweenComparisonPredicateContext)

	// ExitInPredicate is called when exiting the inPredicate production.
	ExitInPredicate(c *InPredicateContext)

	// ExitLikePredicate is called when exiting the likePredicate production.
	ExitLikePredicate(c *LikePredicateContext)

	// ExitIsExpression is called when exiting the isExpression production.
	ExitIsExpression(c *IsExpressionContext)

	// ExitSubqueryExpressionAtom is called when exiting the subqueryExpressionAtom production.
	ExitSubqueryExpressionAtom(c *SubqueryExpressionAtomContext)

	// ExitBinaryComparisonPredicate is called when exiting the binaryComparisonPredicate production.
	ExitBinaryComparisonPredicate(c *BinaryComparisonPredicateContext)

	// ExitSubscriptExpression is called when exiting the subscriptExpression production.
	ExitSubscriptExpression(c *SubscriptExpressionContext)

	// ExitConstantExpressionAtom is called when exiting the constantExpressionAtom production.
	ExitConstantExpressionAtom(c *ConstantExpressionAtomContext)

	// ExitFunctionCallExpressionAtom is called when exiting the functionCallExpressionAtom production.
	ExitFunctionCallExpressionAtom(c *FunctionCallExpressionAtomContext)

	// ExitFullColumnNameExpressionAtom is called when exiting the fullColumnNameExpressionAtom production.
	ExitFullColumnNameExpressionAtom(c *FullColumnNameExpressionAtomContext)

	// ExitBitExpressionAtom is called when exiting the bitExpressionAtom production.
	ExitBitExpressionAtom(c *BitExpressionAtomContext)

	// ExitPreparedStatementParameterAtom is called when exiting the preparedStatementParameterAtom production.
	ExitPreparedStatementParameterAtom(c *PreparedStatementParameterAtomContext)

	// ExitRecordConstructorExpressionAtom is called when exiting the recordConstructorExpressionAtom production.
	ExitRecordConstructorExpressionAtom(c *RecordConstructorExpressionAtomContext)

	// ExitArrayConstructorExpressionAtom is called when exiting the arrayConstructorExpressionAtom production.
	ExitArrayConstructorExpressionAtom(c *ArrayConstructorExpressionAtomContext)

	// ExitMathExpressionAtom is called when exiting the mathExpressionAtom production.
	ExitMathExpressionAtom(c *MathExpressionAtomContext)

	// ExitInList is called when exiting the inList production.
	ExitInList(c *InListContext)

	// ExitPreparedStatementParameter is called when exiting the preparedStatementParameter production.
	ExitPreparedStatementParameter(c *PreparedStatementParameterContext)

	// ExitUnaryOperator is called when exiting the unaryOperator production.
	ExitUnaryOperator(c *UnaryOperatorContext)

	// ExitComparisonOperator is called when exiting the comparisonOperator production.
	ExitComparisonOperator(c *ComparisonOperatorContext)

	// ExitLogicalOperator is called when exiting the logicalOperator production.
	ExitLogicalOperator(c *LogicalOperatorContext)

	// ExitBitOperator is called when exiting the bitOperator production.
	ExitBitOperator(c *BitOperatorContext)

	// ExitMathOperator is called when exiting the mathOperator production.
	ExitMathOperator(c *MathOperatorContext)

	// ExitJsonOperator is called when exiting the jsonOperator production.
	ExitJsonOperator(c *JsonOperatorContext)

	// ExitCharsetNameBase is called when exiting the charsetNameBase production.
	ExitCharsetNameBase(c *CharsetNameBaseContext)

	// ExitIntervalTypeBase is called when exiting the intervalTypeBase production.
	ExitIntervalTypeBase(c *IntervalTypeBaseContext)

	// ExitKeywordsCanBeId is called when exiting the keywordsCanBeId production.
	ExitKeywordsCanBeId(c *KeywordsCanBeIdContext)

	// ExitFunctionNameBase is called when exiting the functionNameBase production.
	ExitFunctionNameBase(c *FunctionNameBaseContext)

	// ExitFunctionNameKeyword is called when exiting the functionNameKeyword production.
	ExitFunctionNameKeyword(c *FunctionNameKeywordContext)
}

RelationalParserListener is a complete listener for a parse tree produced by RelationalParser.

type RelationalParserVisitor

type RelationalParserVisitor interface {
	antlr.ParseTreeVisitor

	// Visit a parse tree produced by RelationalParser#root.
	VisitRoot(ctx *RootContext) interface{}

	// Visit a parse tree produced by RelationalParser#statements.
	VisitStatements(ctx *StatementsContext) interface{}

	// Visit a parse tree produced by RelationalParser#statement.
	VisitStatement(ctx *StatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#dmlStatement.
	VisitDmlStatement(ctx *DmlStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#ddlStatement.
	VisitDdlStatement(ctx *DdlStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#transactionStatement.
	VisitTransactionStatement(ctx *TransactionStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#preparedStatement.
	VisitPreparedStatement(ctx *PreparedStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#administrationStatement.
	VisitAdministrationStatement(ctx *AdministrationStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#utilityStatement.
	VisitUtilityStatement(ctx *UtilityStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#templateClause.
	VisitTemplateClause(ctx *TemplateClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#createSchemaStatement.
	VisitCreateSchemaStatement(ctx *CreateSchemaStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#createSchemaTemplateStatement.
	VisitCreateSchemaTemplateStatement(ctx *CreateSchemaTemplateStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#createDatabaseStatement.
	VisitCreateDatabaseStatement(ctx *CreateDatabaseStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#optionsClause.
	VisitOptionsClause(ctx *OptionsClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#option.
	VisitOption(ctx *OptionContext) interface{}

	// Visit a parse tree produced by RelationalParser#dropDatabaseStatement.
	VisitDropDatabaseStatement(ctx *DropDatabaseStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#dropSchemaTemplateStatement.
	VisitDropSchemaTemplateStatement(ctx *DropSchemaTemplateStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#dropSchemaStatement.
	VisitDropSchemaStatement(ctx *DropSchemaStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#structDefinition.
	VisitStructDefinition(ctx *StructDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#tableDefinition.
	VisitTableDefinition(ctx *TableDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#columnDefinition.
	VisitColumnDefinition(ctx *ColumnDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#functionColumnType.
	VisitFunctionColumnType(ctx *FunctionColumnTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#columnType.
	VisitColumnType(ctx *ColumnTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#primitiveType.
	VisitPrimitiveType(ctx *PrimitiveTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#vectorType.
	VisitVectorType(ctx *VectorTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#vectorElementType.
	VisitVectorElementType(ctx *VectorElementTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#nullColumnConstraint.
	VisitNullColumnConstraint(ctx *NullColumnConstraintContext) interface{}

	// Visit a parse tree produced by RelationalParser#primaryKeyDefinition.
	VisitPrimaryKeyDefinition(ctx *PrimaryKeyDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#fullIdList.
	VisitFullIdList(ctx *FullIdListContext) interface{}

	// Visit a parse tree produced by RelationalParser#enumDefinition.
	VisitEnumDefinition(ctx *EnumDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexAsSelectDefinition.
	VisitIndexAsSelectDefinition(ctx *IndexAsSelectDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexOnSourceDefinition.
	VisitIndexOnSourceDefinition(ctx *IndexOnSourceDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#vectorIndexDefinition.
	VisitVectorIndexDefinition(ctx *VectorIndexDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#vectorEngine.
	VisitVectorEngine(ctx *VectorEngineContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexColumnList.
	VisitIndexColumnList(ctx *IndexColumnListContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexColumnSpec.
	VisitIndexColumnSpec(ctx *IndexColumnSpecContext) interface{}

	// Visit a parse tree produced by RelationalParser#includeClause.
	VisitIncludeClause(ctx *IncludeClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexType.
	VisitIndexType(ctx *IndexTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexPartitionClause.
	VisitIndexPartitionClause(ctx *IndexPartitionClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexOptions.
	VisitIndexOptions(ctx *IndexOptionsContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexOption.
	VisitIndexOption(ctx *IndexOptionContext) interface{}

	// Visit a parse tree produced by RelationalParser#vectorIndexOptions.
	VisitVectorIndexOptions(ctx *VectorIndexOptionsContext) interface{}

	// Visit a parse tree produced by RelationalParser#vectorIndexOption.
	VisitVectorIndexOption(ctx *VectorIndexOptionContext) interface{}

	// Visit a parse tree produced by RelationalParser#vectorIndexOptionValue.
	VisitVectorIndexOptionValue(ctx *VectorIndexOptionValueContext) interface{}

	// Visit a parse tree produced by RelationalParser#hnswMetric.
	VisitHnswMetric(ctx *HnswMetricContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexAttributes.
	VisitIndexAttributes(ctx *IndexAttributesContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexAttribute.
	VisitIndexAttribute(ctx *IndexAttributeContext) interface{}

	// Visit a parse tree produced by RelationalParser#createTempFunction.
	VisitCreateTempFunction(ctx *CreateTempFunctionContext) interface{}

	// Visit a parse tree produced by RelationalParser#dropTempFunction.
	VisitDropTempFunction(ctx *DropTempFunctionContext) interface{}

	// Visit a parse tree produced by RelationalParser#viewDefinition.
	VisitViewDefinition(ctx *ViewDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#storedQueryDefinition.
	VisitStoredQueryDefinition(ctx *StoredQueryDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#declareBlock.
	VisitDeclareBlock(ctx *DeclareBlockContext) interface{}

	// Visit a parse tree produced by RelationalParser#declaredFunction.
	VisitDeclaredFunction(ctx *DeclaredFunctionContext) interface{}

	// Visit a parse tree produced by RelationalParser#tempSqlInvokedFunction.
	VisitTempSqlInvokedFunction(ctx *TempSqlInvokedFunctionContext) interface{}

	// Visit a parse tree produced by RelationalParser#sqlInvokedFunction.
	VisitSqlInvokedFunction(ctx *SqlInvokedFunctionContext) interface{}

	// Visit a parse tree produced by RelationalParser#functionSpecification.
	VisitFunctionSpecification(ctx *FunctionSpecificationContext) interface{}

	// Visit a parse tree produced by RelationalParser#sqlParameterDeclarationList.
	VisitSqlParameterDeclarationList(ctx *SqlParameterDeclarationListContext) interface{}

	// Visit a parse tree produced by RelationalParser#sqlParameterDeclarations.
	VisitSqlParameterDeclarations(ctx *SqlParameterDeclarationsContext) interface{}

	// Visit a parse tree produced by RelationalParser#sqlParameterDeclaration.
	VisitSqlParameterDeclaration(ctx *SqlParameterDeclarationContext) interface{}

	// Visit a parse tree produced by RelationalParser#parameterMode.
	VisitParameterMode(ctx *ParameterModeContext) interface{}

	// Visit a parse tree produced by RelationalParser#returnsClause.
	VisitReturnsClause(ctx *ReturnsClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#returnsType.
	VisitReturnsType(ctx *ReturnsTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#returnsTableType.
	VisitReturnsTableType(ctx *ReturnsTableTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#tableFunctionColumnList.
	VisitTableFunctionColumnList(ctx *TableFunctionColumnListContext) interface{}

	// Visit a parse tree produced by RelationalParser#tableFunctionColumnListElement.
	VisitTableFunctionColumnListElement(ctx *TableFunctionColumnListElementContext) interface{}

	// Visit a parse tree produced by RelationalParser#routineCharacteristics.
	VisitRoutineCharacteristics(ctx *RoutineCharacteristicsContext) interface{}

	// Visit a parse tree produced by RelationalParser#languageClause.
	VisitLanguageClause(ctx *LanguageClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#languageName.
	VisitLanguageName(ctx *LanguageNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#parameterStyle.
	VisitParameterStyle(ctx *ParameterStyleContext) interface{}

	// Visit a parse tree produced by RelationalParser#deterministicCharacteristic.
	VisitDeterministicCharacteristic(ctx *DeterministicCharacteristicContext) interface{}

	// Visit a parse tree produced by RelationalParser#nullCallClause.
	VisitNullCallClause(ctx *NullCallClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#dispatchClause.
	VisitDispatchClause(ctx *DispatchClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#statementBody.
	VisitStatementBody(ctx *StatementBodyContext) interface{}

	// Visit a parse tree produced by RelationalParser#userDefinedMacroFunctionStatementBody.
	VisitUserDefinedMacroFunctionStatementBody(ctx *UserDefinedMacroFunctionStatementBodyContext) interface{}

	// Visit a parse tree produced by RelationalParser#charSet.
	VisitCharSet(ctx *CharSetContext) interface{}

	// Visit a parse tree produced by RelationalParser#intervalType.
	VisitIntervalType(ctx *IntervalTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#schemaId.
	VisitSchemaId(ctx *SchemaIdContext) interface{}

	// Visit a parse tree produced by RelationalParser#path.
	VisitPath(ctx *PathContext) interface{}

	// Visit a parse tree produced by RelationalParser#schemaTemplateId.
	VisitSchemaTemplateId(ctx *SchemaTemplateIdContext) interface{}

	// Visit a parse tree produced by RelationalParser#deleteStatement.
	VisitDeleteStatement(ctx *DeleteStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#insertStatement.
	VisitInsertStatement(ctx *InsertStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#continuationAtom.
	VisitContinuationAtom(ctx *ContinuationAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#selectStatement.
	VisitSelectStatement(ctx *SelectStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#query.
	VisitQuery(ctx *QueryContext) interface{}

	// Visit a parse tree produced by RelationalParser#ctes.
	VisitCtes(ctx *CtesContext) interface{}

	// Visit a parse tree produced by RelationalParser#traversalOrderClause.
	VisitTraversalOrderClause(ctx *TraversalOrderClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#namedQuery.
	VisitNamedQuery(ctx *NamedQueryContext) interface{}

	// Visit a parse tree produced by RelationalParser#tableFunction.
	VisitTableFunction(ctx *TableFunctionContext) interface{}

	// Visit a parse tree produced by RelationalParser#namedOrUnnamedFunctionArgs.
	VisitNamedOrUnnamedFunctionArgs(ctx *NamedOrUnnamedFunctionArgsContext) interface{}

	// Visit a parse tree produced by RelationalParser#tableFunctionName.
	VisitTableFunctionName(ctx *TableFunctionNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#queryTermDefault.
	VisitQueryTermDefault(ctx *QueryTermDefaultContext) interface{}

	// Visit a parse tree produced by RelationalParser#setQuery.
	VisitSetQuery(ctx *SetQueryContext) interface{}

	// Visit a parse tree produced by RelationalParser#insertStatementValueSelect.
	VisitInsertStatementValueSelect(ctx *InsertStatementValueSelectContext) interface{}

	// Visit a parse tree produced by RelationalParser#insertStatementValueValues.
	VisitInsertStatementValueValues(ctx *InsertStatementValueValuesContext) interface{}

	// Visit a parse tree produced by RelationalParser#updatedElement.
	VisitUpdatedElement(ctx *UpdatedElementContext) interface{}

	// Visit a parse tree produced by RelationalParser#assignmentField.
	VisitAssignmentField(ctx *AssignmentFieldContext) interface{}

	// Visit a parse tree produced by RelationalParser#updateStatement.
	VisitUpdateStatement(ctx *UpdateStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#orderByClause.
	VisitOrderByClause(ctx *OrderByClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#orderByExpression.
	VisitOrderByExpression(ctx *OrderByExpressionContext) interface{}

	// Visit a parse tree produced by RelationalParser#orderClause.
	VisitOrderClause(ctx *OrderClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#tableSources.
	VisitTableSources(ctx *TableSourcesContext) interface{}

	// Visit a parse tree produced by RelationalParser#tableSourceBase.
	VisitTableSourceBase(ctx *TableSourceBaseContext) interface{}

	// Visit a parse tree produced by RelationalParser#atomTableItem.
	VisitAtomTableItem(ctx *AtomTableItemContext) interface{}

	// Visit a parse tree produced by RelationalParser#subqueryTableItem.
	VisitSubqueryTableItem(ctx *SubqueryTableItemContext) interface{}

	// Visit a parse tree produced by RelationalParser#inlineTableItem.
	VisitInlineTableItem(ctx *InlineTableItemContext) interface{}

	// Visit a parse tree produced by RelationalParser#tableValuedFunction.
	VisitTableValuedFunction(ctx *TableValuedFunctionContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexHint.
	VisitIndexHint(ctx *IndexHintContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexHintType.
	VisitIndexHintType(ctx *IndexHintTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#inlineTableDefinition.
	VisitInlineTableDefinition(ctx *InlineTableDefinitionContext) interface{}

	// Visit a parse tree produced by RelationalParser#innerJoin.
	VisitInnerJoin(ctx *InnerJoinContext) interface{}

	// Visit a parse tree produced by RelationalParser#straightJoin.
	VisitStraightJoin(ctx *StraightJoinContext) interface{}

	// Visit a parse tree produced by RelationalParser#outerJoin.
	VisitOuterJoin(ctx *OuterJoinContext) interface{}

	// Visit a parse tree produced by RelationalParser#naturalJoin.
	VisitNaturalJoin(ctx *NaturalJoinContext) interface{}

	// Visit a parse tree produced by RelationalParser#simpleTable.
	VisitSimpleTable(ctx *SimpleTableContext) interface{}

	// Visit a parse tree produced by RelationalParser#parenthesisQuery.
	VisitParenthesisQuery(ctx *ParenthesisQueryContext) interface{}

	// Visit a parse tree produced by RelationalParser#selectElements.
	VisitSelectElements(ctx *SelectElementsContext) interface{}

	// Visit a parse tree produced by RelationalParser#selectStarElement.
	VisitSelectStarElement(ctx *SelectStarElementContext) interface{}

	// Visit a parse tree produced by RelationalParser#selectQualifierStarElement.
	VisitSelectQualifierStarElement(ctx *SelectQualifierStarElementContext) interface{}

	// Visit a parse tree produced by RelationalParser#selectExpressionElement.
	VisitSelectExpressionElement(ctx *SelectExpressionElementContext) interface{}

	// Visit a parse tree produced by RelationalParser#fromClause.
	VisitFromClause(ctx *FromClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#groupByClause.
	VisitGroupByClause(ctx *GroupByClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#whereExpr.
	VisitWhereExpr(ctx *WhereExprContext) interface{}

	// Visit a parse tree produced by RelationalParser#havingClause.
	VisitHavingClause(ctx *HavingClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#qualifyClause.
	VisitQualifyClause(ctx *QualifyClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#groupByItem.
	VisitGroupByItem(ctx *GroupByItemContext) interface{}

	// Visit a parse tree produced by RelationalParser#limitClause.
	VisitLimitClause(ctx *LimitClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#limitClauseAtom.
	VisitLimitClauseAtom(ctx *LimitClauseAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#statementOptions.
	VisitStatementOptions(ctx *StatementOptionsContext) interface{}

	// Visit a parse tree produced by RelationalParser#statementOption.
	VisitStatementOption(ctx *StatementOptionContext) interface{}

	// Visit a parse tree produced by RelationalParser#startTransaction.
	VisitStartTransaction(ctx *StartTransactionContext) interface{}

	// Visit a parse tree produced by RelationalParser#commitStatement.
	VisitCommitStatement(ctx *CommitStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#rollbackStatement.
	VisitRollbackStatement(ctx *RollbackStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#setAutocommitStatement.
	VisitSetAutocommitStatement(ctx *SetAutocommitStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#setTransactionStatement.
	VisitSetTransactionStatement(ctx *SetTransactionStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#transactionOption.
	VisitTransactionOption(ctx *TransactionOptionContext) interface{}

	// Visit a parse tree produced by RelationalParser#transactionLevel.
	VisitTransactionLevel(ctx *TransactionLevelContext) interface{}

	// Visit a parse tree produced by RelationalParser#prepareStatement.
	VisitPrepareStatement(ctx *PrepareStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#executeStatement.
	VisitExecuteStatement(ctx *ExecuteStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#showDatabasesStatement.
	VisitShowDatabasesStatement(ctx *ShowDatabasesStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#showSchemaTemplatesStatement.
	VisitShowSchemaTemplatesStatement(ctx *ShowSchemaTemplatesStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#setVariable.
	VisitSetVariable(ctx *SetVariableContext) interface{}

	// Visit a parse tree produced by RelationalParser#setCharset.
	VisitSetCharset(ctx *SetCharsetContext) interface{}

	// Visit a parse tree produced by RelationalParser#setNames.
	VisitSetNames(ctx *SetNamesContext) interface{}

	// Visit a parse tree produced by RelationalParser#setTransaction.
	VisitSetTransaction(ctx *SetTransactionContext) interface{}

	// Visit a parse tree produced by RelationalParser#setAutocommit.
	VisitSetAutocommit(ctx *SetAutocommitContext) interface{}

	// Visit a parse tree produced by RelationalParser#setNewValueInsideTrigger.
	VisitSetNewValueInsideTrigger(ctx *SetNewValueInsideTriggerContext) interface{}

	// Visit a parse tree produced by RelationalParser#variableClause.
	VisitVariableClause(ctx *VariableClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#killStatement.
	VisitKillStatement(ctx *KillStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#resetStatement.
	VisitResetStatement(ctx *ResetStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#executeContinuationStatement.
	VisitExecuteContinuationStatement(ctx *ExecuteContinuationStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#copyExportStatement.
	VisitCopyExportStatement(ctx *CopyExportStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#copyImportStatement.
	VisitCopyImportStatement(ctx *CopyImportStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#tableIndexes.
	VisitTableIndexes(ctx *TableIndexesContext) interface{}

	// Visit a parse tree produced by RelationalParser#loadedTableIndexes.
	VisitLoadedTableIndexes(ctx *LoadedTableIndexesContext) interface{}

	// Visit a parse tree produced by RelationalParser#simpleDescribeSchemaStatement.
	VisitSimpleDescribeSchemaStatement(ctx *SimpleDescribeSchemaStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#simpleDescribeSchemaTemplateStatement.
	VisitSimpleDescribeSchemaTemplateStatement(ctx *SimpleDescribeSchemaTemplateStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#fullDescribeStatement.
	VisitFullDescribeStatement(ctx *FullDescribeStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#helpStatement.
	VisitHelpStatement(ctx *HelpStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#describeStatements.
	VisitDescribeStatements(ctx *DescribeStatementsContext) interface{}

	// Visit a parse tree produced by RelationalParser#describeConnection.
	VisitDescribeConnection(ctx *DescribeConnectionContext) interface{}

	// Visit a parse tree produced by RelationalParser#fullId.
	VisitFullId(ctx *FullIdContext) interface{}

	// Visit a parse tree produced by RelationalParser#tableName.
	VisitTableName(ctx *TableNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#fullColumnName.
	VisitFullColumnName(ctx *FullColumnNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexColumnName.
	VisitIndexColumnName(ctx *IndexColumnNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#charsetName.
	VisitCharsetName(ctx *CharsetNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#collationName.
	VisitCollationName(ctx *CollationNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#uid.
	VisitUid(ctx *UidContext) interface{}

	// Visit a parse tree produced by RelationalParser#simpleId.
	VisitSimpleId(ctx *SimpleIdContext) interface{}

	// Visit a parse tree produced by RelationalParser#nullNotnull.
	VisitNullNotnull(ctx *NullNotnullContext) interface{}

	// Visit a parse tree produced by RelationalParser#decimalLiteral.
	VisitDecimalLiteral(ctx *DecimalLiteralContext) interface{}

	// Visit a parse tree produced by RelationalParser#stringLiteral.
	VisitStringLiteral(ctx *StringLiteralContext) interface{}

	// Visit a parse tree produced by RelationalParser#booleanLiteral.
	VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{}

	// Visit a parse tree produced by RelationalParser#bytesLiteral.
	VisitBytesLiteral(ctx *BytesLiteralContext) interface{}

	// Visit a parse tree produced by RelationalParser#nullLiteral.
	VisitNullLiteral(ctx *NullLiteralContext) interface{}

	// Visit a parse tree produced by RelationalParser#stringConstant.
	VisitStringConstant(ctx *StringConstantContext) interface{}

	// Visit a parse tree produced by RelationalParser#decimalConstant.
	VisitDecimalConstant(ctx *DecimalConstantContext) interface{}

	// Visit a parse tree produced by RelationalParser#negativeDecimalConstant.
	VisitNegativeDecimalConstant(ctx *NegativeDecimalConstantContext) interface{}

	// Visit a parse tree produced by RelationalParser#bytesConstant.
	VisitBytesConstant(ctx *BytesConstantContext) interface{}

	// Visit a parse tree produced by RelationalParser#booleanConstant.
	VisitBooleanConstant(ctx *BooleanConstantContext) interface{}

	// Visit a parse tree produced by RelationalParser#bitStringConstant.
	VisitBitStringConstant(ctx *BitStringConstantContext) interface{}

	// Visit a parse tree produced by RelationalParser#nullConstant.
	VisitNullConstant(ctx *NullConstantContext) interface{}

	// Visit a parse tree produced by RelationalParser#stringDataType.
	VisitStringDataType(ctx *StringDataTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#nationalStringDataType.
	VisitNationalStringDataType(ctx *NationalStringDataTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#nationalVaryingStringDataType.
	VisitNationalVaryingStringDataType(ctx *NationalVaryingStringDataTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#dimensionDataType.
	VisitDimensionDataType(ctx *DimensionDataTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#simpleDataType.
	VisitSimpleDataType(ctx *SimpleDataTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#collectionDataType.
	VisitCollectionDataType(ctx *CollectionDataTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#spatialDataType.
	VisitSpatialDataType(ctx *SpatialDataTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#longVarcharDataType.
	VisitLongVarcharDataType(ctx *LongVarcharDataTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#longVarbinaryDataType.
	VisitLongVarbinaryDataType(ctx *LongVarbinaryDataTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#collectionOptions.
	VisitCollectionOptions(ctx *CollectionOptionsContext) interface{}

	// Visit a parse tree produced by RelationalParser#convertedDataType.
	VisitConvertedDataType(ctx *ConvertedDataTypeContext) interface{}

	// Visit a parse tree produced by RelationalParser#lengthOneDimension.
	VisitLengthOneDimension(ctx *LengthOneDimensionContext) interface{}

	// Visit a parse tree produced by RelationalParser#lengthTwoDimension.
	VisitLengthTwoDimension(ctx *LengthTwoDimensionContext) interface{}

	// Visit a parse tree produced by RelationalParser#lengthTwoOptionalDimension.
	VisitLengthTwoOptionalDimension(ctx *LengthTwoOptionalDimensionContext) interface{}

	// Visit a parse tree produced by RelationalParser#uidList.
	VisitUidList(ctx *UidListContext) interface{}

	// Visit a parse tree produced by RelationalParser#uidWithNestings.
	VisitUidWithNestings(ctx *UidWithNestingsContext) interface{}

	// Visit a parse tree produced by RelationalParser#uidListWithNestingsInParens.
	VisitUidListWithNestingsInParens(ctx *UidListWithNestingsInParensContext) interface{}

	// Visit a parse tree produced by RelationalParser#uidListWithNestings.
	VisitUidListWithNestings(ctx *UidListWithNestingsContext) interface{}

	// Visit a parse tree produced by RelationalParser#tables.
	VisitTables(ctx *TablesContext) interface{}

	// Visit a parse tree produced by RelationalParser#indexColumnNames.
	VisitIndexColumnNames(ctx *IndexColumnNamesContext) interface{}

	// Visit a parse tree produced by RelationalParser#expressions.
	VisitExpressions(ctx *ExpressionsContext) interface{}

	// Visit a parse tree produced by RelationalParser#expressionsWithDefaults.
	VisitExpressionsWithDefaults(ctx *ExpressionsWithDefaultsContext) interface{}

	// Visit a parse tree produced by RelationalParser#recordConstructorForInsert.
	VisitRecordConstructorForInsert(ctx *RecordConstructorForInsertContext) interface{}

	// Visit a parse tree produced by RelationalParser#recordConstructorForInlineTable.
	VisitRecordConstructorForInlineTable(ctx *RecordConstructorForInlineTableContext) interface{}

	// Visit a parse tree produced by RelationalParser#recordConstructor.
	VisitRecordConstructor(ctx *RecordConstructorContext) interface{}

	// Visit a parse tree produced by RelationalParser#ofTypeClause.
	VisitOfTypeClause(ctx *OfTypeClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#arrayConstructor.
	VisitArrayConstructor(ctx *ArrayConstructorContext) interface{}

	// Visit a parse tree produced by RelationalParser#userVariables.
	VisitUserVariables(ctx *UserVariablesContext) interface{}

	// Visit a parse tree produced by RelationalParser#defaultValue.
	VisitDefaultValue(ctx *DefaultValueContext) interface{}

	// Visit a parse tree produced by RelationalParser#currentTimestamp.
	VisitCurrentTimestamp(ctx *CurrentTimestampContext) interface{}

	// Visit a parse tree produced by RelationalParser#expressionOrDefault.
	VisitExpressionOrDefault(ctx *ExpressionOrDefaultContext) interface{}

	// Visit a parse tree produced by RelationalParser#expressionWithOptionalName.
	VisitExpressionWithOptionalName(ctx *ExpressionWithOptionalNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#ifExists.
	VisitIfExists(ctx *IfExistsContext) interface{}

	// Visit a parse tree produced by RelationalParser#ifNotExists.
	VisitIfNotExists(ctx *IfNotExistsContext) interface{}

	// Visit a parse tree produced by RelationalParser#aggregateFunctionCall.
	VisitAggregateFunctionCall(ctx *AggregateFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#nonAggregateFunctionCall.
	VisitNonAggregateFunctionCall(ctx *NonAggregateFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#specificFunctionCall.
	VisitSpecificFunctionCall(ctx *SpecificFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#scalarFunctionCall.
	VisitScalarFunctionCall(ctx *ScalarFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#userDefinedScalarFunctionCall.
	VisitUserDefinedScalarFunctionCall(ctx *UserDefinedScalarFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#simpleFunctionCall.
	VisitSimpleFunctionCall(ctx *SimpleFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#dataTypeFunctionCall.
	VisitDataTypeFunctionCall(ctx *DataTypeFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#valuesFunctionCall.
	VisitValuesFunctionCall(ctx *ValuesFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#caseExpressionFunctionCall.
	VisitCaseExpressionFunctionCall(ctx *CaseExpressionFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#caseFunctionCall.
	VisitCaseFunctionCall(ctx *CaseFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#charFunctionCall.
	VisitCharFunctionCall(ctx *CharFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#positionFunctionCall.
	VisitPositionFunctionCall(ctx *PositionFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#substrFunctionCall.
	VisitSubstrFunctionCall(ctx *SubstrFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#trimFunctionCall.
	VisitTrimFunctionCall(ctx *TrimFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#weightFunctionCall.
	VisitWeightFunctionCall(ctx *WeightFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#extractFunctionCall.
	VisitExtractFunctionCall(ctx *ExtractFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#getFormatFunctionCall.
	VisitGetFormatFunctionCall(ctx *GetFormatFunctionCallContext) interface{}

	// Visit a parse tree produced by RelationalParser#caseFuncAlternative.
	VisitCaseFuncAlternative(ctx *CaseFuncAlternativeContext) interface{}

	// Visit a parse tree produced by RelationalParser#levelWeightList.
	VisitLevelWeightList(ctx *LevelWeightListContext) interface{}

	// Visit a parse tree produced by RelationalParser#levelWeightRange.
	VisitLevelWeightRange(ctx *LevelWeightRangeContext) interface{}

	// Visit a parse tree produced by RelationalParser#levelInWeightListElement.
	VisitLevelInWeightListElement(ctx *LevelInWeightListElementContext) interface{}

	// Visit a parse tree produced by RelationalParser#aggregateWindowedFunction.
	VisitAggregateWindowedFunction(ctx *AggregateWindowedFunctionContext) interface{}

	// Visit a parse tree produced by RelationalParser#nullTreatmentClause.
	VisitNullTreatmentClause(ctx *NullTreatmentClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#aggregateLimitClause.
	VisitAggregateLimitClause(ctx *AggregateLimitClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#nonAggregateWindowedFunction.
	VisitNonAggregateWindowedFunction(ctx *NonAggregateWindowedFunctionContext) interface{}

	// Visit a parse tree produced by RelationalParser#overClause.
	VisitOverClause(ctx *OverClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#windowName.
	VisitWindowName(ctx *WindowNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#windowSpec.
	VisitWindowSpec(ctx *WindowSpecContext) interface{}

	// Visit a parse tree produced by RelationalParser#windowOptionsClause.
	VisitWindowOptionsClause(ctx *WindowOptionsClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#windowOption.
	VisitWindowOption(ctx *WindowOptionContext) interface{}

	// Visit a parse tree produced by RelationalParser#partitionClause.
	VisitPartitionClause(ctx *PartitionClauseContext) interface{}

	// Visit a parse tree produced by RelationalParser#scalarFunctionName.
	VisitScalarFunctionName(ctx *ScalarFunctionNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#userDefinedScalarFunctionName.
	VisitUserDefinedScalarFunctionName(ctx *UserDefinedScalarFunctionNameContext) interface{}

	// Visit a parse tree produced by RelationalParser#functionArgs.
	VisitFunctionArgs(ctx *FunctionArgsContext) interface{}

	// Visit a parse tree produced by RelationalParser#functionArg.
	VisitFunctionArg(ctx *FunctionArgContext) interface{}

	// Visit a parse tree produced by RelationalParser#namedFunctionArg.
	VisitNamedFunctionArg(ctx *NamedFunctionArgContext) interface{}

	// Visit a parse tree produced by RelationalParser#predicatedExpression.
	VisitPredicatedExpression(ctx *PredicatedExpressionContext) interface{}

	// Visit a parse tree produced by RelationalParser#notExpression.
	VisitNotExpression(ctx *NotExpressionContext) interface{}

	// Visit a parse tree produced by RelationalParser#logicalExpression.
	VisitLogicalExpression(ctx *LogicalExpressionContext) interface{}

	// Visit a parse tree produced by RelationalParser#existsExpressionAtom.
	VisitExistsExpressionAtom(ctx *ExistsExpressionAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#betweenComparisonPredicate.
	VisitBetweenComparisonPredicate(ctx *BetweenComparisonPredicateContext) interface{}

	// Visit a parse tree produced by RelationalParser#inPredicate.
	VisitInPredicate(ctx *InPredicateContext) interface{}

	// Visit a parse tree produced by RelationalParser#likePredicate.
	VisitLikePredicate(ctx *LikePredicateContext) interface{}

	// Visit a parse tree produced by RelationalParser#isExpression.
	VisitIsExpression(ctx *IsExpressionContext) interface{}

	// Visit a parse tree produced by RelationalParser#subqueryExpressionAtom.
	VisitSubqueryExpressionAtom(ctx *SubqueryExpressionAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#binaryComparisonPredicate.
	VisitBinaryComparisonPredicate(ctx *BinaryComparisonPredicateContext) interface{}

	// Visit a parse tree produced by RelationalParser#subscriptExpression.
	VisitSubscriptExpression(ctx *SubscriptExpressionContext) interface{}

	// Visit a parse tree produced by RelationalParser#constantExpressionAtom.
	VisitConstantExpressionAtom(ctx *ConstantExpressionAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#functionCallExpressionAtom.
	VisitFunctionCallExpressionAtom(ctx *FunctionCallExpressionAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#fullColumnNameExpressionAtom.
	VisitFullColumnNameExpressionAtom(ctx *FullColumnNameExpressionAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#bitExpressionAtom.
	VisitBitExpressionAtom(ctx *BitExpressionAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#preparedStatementParameterAtom.
	VisitPreparedStatementParameterAtom(ctx *PreparedStatementParameterAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#recordConstructorExpressionAtom.
	VisitRecordConstructorExpressionAtom(ctx *RecordConstructorExpressionAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#arrayConstructorExpressionAtom.
	VisitArrayConstructorExpressionAtom(ctx *ArrayConstructorExpressionAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#mathExpressionAtom.
	VisitMathExpressionAtom(ctx *MathExpressionAtomContext) interface{}

	// Visit a parse tree produced by RelationalParser#inList.
	VisitInList(ctx *InListContext) interface{}

	// Visit a parse tree produced by RelationalParser#preparedStatementParameter.
	VisitPreparedStatementParameter(ctx *PreparedStatementParameterContext) interface{}

	// Visit a parse tree produced by RelationalParser#unaryOperator.
	VisitUnaryOperator(ctx *UnaryOperatorContext) interface{}

	// Visit a parse tree produced by RelationalParser#comparisonOperator.
	VisitComparisonOperator(ctx *ComparisonOperatorContext) interface{}

	// Visit a parse tree produced by RelationalParser#logicalOperator.
	VisitLogicalOperator(ctx *LogicalOperatorContext) interface{}

	// Visit a parse tree produced by RelationalParser#bitOperator.
	VisitBitOperator(ctx *BitOperatorContext) interface{}

	// Visit a parse tree produced by RelationalParser#mathOperator.
	VisitMathOperator(ctx *MathOperatorContext) interface{}

	// Visit a parse tree produced by RelationalParser#jsonOperator.
	VisitJsonOperator(ctx *JsonOperatorContext) interface{}

	// Visit a parse tree produced by RelationalParser#charsetNameBase.
	VisitCharsetNameBase(ctx *CharsetNameBaseContext) interface{}

	// Visit a parse tree produced by RelationalParser#intervalTypeBase.
	VisitIntervalTypeBase(ctx *IntervalTypeBaseContext) interface{}

	// Visit a parse tree produced by RelationalParser#keywordsCanBeId.
	VisitKeywordsCanBeId(ctx *KeywordsCanBeIdContext) interface{}

	// Visit a parse tree produced by RelationalParser#functionNameBase.
	VisitFunctionNameBase(ctx *FunctionNameBaseContext) interface{}

	// Visit a parse tree produced by RelationalParser#functionNameKeyword.
	VisitFunctionNameKeyword(ctx *FunctionNameKeywordContext) interface{}
}

A complete Visitor for a parse tree produced by RelationalParser.

type ResetStatementContext

type ResetStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyResetStatementContext

func NewEmptyResetStatementContext() *ResetStatementContext

func NewResetStatementContext

func NewResetStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ResetStatementContext

func (*ResetStatementContext) Accept

func (s *ResetStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ResetStatementContext) CACHE

func (*ResetStatementContext) EnterRule

func (s *ResetStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*ResetStatementContext) ExitRule

func (s *ResetStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*ResetStatementContext) GetParser

func (s *ResetStatementContext) GetParser() antlr.Parser

func (*ResetStatementContext) GetRuleContext

func (s *ResetStatementContext) GetRuleContext() antlr.RuleContext

func (*ResetStatementContext) IsResetStatementContext

func (*ResetStatementContext) IsResetStatementContext()

func (*ResetStatementContext) QUERY

func (*ResetStatementContext) RESET

func (*ResetStatementContext) ToStringTree

func (s *ResetStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ReturnsClauseContext

type ReturnsClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyReturnsClauseContext

func NewEmptyReturnsClauseContext() *ReturnsClauseContext

func NewReturnsClauseContext

func NewReturnsClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnsClauseContext

func (*ReturnsClauseContext) Accept

func (s *ReturnsClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ReturnsClauseContext) EnterRule

func (s *ReturnsClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*ReturnsClauseContext) ExitRule

func (s *ReturnsClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*ReturnsClauseContext) GetParser

func (s *ReturnsClauseContext) GetParser() antlr.Parser

func (*ReturnsClauseContext) GetRuleContext

func (s *ReturnsClauseContext) GetRuleContext() antlr.RuleContext

func (*ReturnsClauseContext) IsReturnsClauseContext

func (*ReturnsClauseContext) IsReturnsClauseContext()

func (*ReturnsClauseContext) RETURNS

func (*ReturnsClauseContext) ReturnsType

func (s *ReturnsClauseContext) ReturnsType() IReturnsTypeContext

func (*ReturnsClauseContext) ToStringTree

func (s *ReturnsClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ReturnsTableTypeContext

type ReturnsTableTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyReturnsTableTypeContext

func NewEmptyReturnsTableTypeContext() *ReturnsTableTypeContext

func NewReturnsTableTypeContext

func NewReturnsTableTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnsTableTypeContext

func (*ReturnsTableTypeContext) Accept

func (s *ReturnsTableTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ReturnsTableTypeContext) EnterRule

func (s *ReturnsTableTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*ReturnsTableTypeContext) ExitRule

func (s *ReturnsTableTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*ReturnsTableTypeContext) GetParser

func (s *ReturnsTableTypeContext) GetParser() antlr.Parser

func (*ReturnsTableTypeContext) GetRuleContext

func (s *ReturnsTableTypeContext) GetRuleContext() antlr.RuleContext

func (*ReturnsTableTypeContext) IsReturnsTableTypeContext

func (*ReturnsTableTypeContext) IsReturnsTableTypeContext()

func (*ReturnsTableTypeContext) TABLE

func (*ReturnsTableTypeContext) TableFunctionColumnList

func (s *ReturnsTableTypeContext) TableFunctionColumnList() ITableFunctionColumnListContext

func (*ReturnsTableTypeContext) ToStringTree

func (s *ReturnsTableTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ReturnsTypeContext

type ReturnsTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyReturnsTypeContext

func NewEmptyReturnsTypeContext() *ReturnsTypeContext

func NewReturnsTypeContext

func NewReturnsTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnsTypeContext

func (*ReturnsTypeContext) ARRAY

func (*ReturnsTypeContext) Accept

func (s *ReturnsTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ReturnsTypeContext) ColumnType

func (s *ReturnsTypeContext) ColumnType() IColumnTypeContext

func (*ReturnsTypeContext) EnterRule

func (s *ReturnsTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*ReturnsTypeContext) ExitRule

func (s *ReturnsTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*ReturnsTypeContext) GetParser

func (s *ReturnsTypeContext) GetParser() antlr.Parser

func (*ReturnsTypeContext) GetReturnsDataType

func (s *ReturnsTypeContext) GetReturnsDataType() IColumnTypeContext

func (*ReturnsTypeContext) GetRuleContext

func (s *ReturnsTypeContext) GetRuleContext() antlr.RuleContext

func (*ReturnsTypeContext) IsReturnsTypeContext

func (*ReturnsTypeContext) IsReturnsTypeContext()

func (*ReturnsTypeContext) ReturnsTableType

func (s *ReturnsTypeContext) ReturnsTableType() IReturnsTableTypeContext

func (*ReturnsTypeContext) SetReturnsDataType

func (s *ReturnsTypeContext) SetReturnsDataType(v IColumnTypeContext)

func (*ReturnsTypeContext) ToStringTree

func (s *ReturnsTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type RollbackStatementContext

type RollbackStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRollbackStatementContext

func NewEmptyRollbackStatementContext() *RollbackStatementContext

func NewRollbackStatementContext

func NewRollbackStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RollbackStatementContext

func (*RollbackStatementContext) Accept

func (s *RollbackStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*RollbackStatementContext) EnterRule

func (s *RollbackStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*RollbackStatementContext) ExitRule

func (s *RollbackStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*RollbackStatementContext) GetParser

func (s *RollbackStatementContext) GetParser() antlr.Parser

func (*RollbackStatementContext) GetRuleContext

func (s *RollbackStatementContext) GetRuleContext() antlr.RuleContext

func (*RollbackStatementContext) IsRollbackStatementContext

func (*RollbackStatementContext) IsRollbackStatementContext()

func (*RollbackStatementContext) ROLLBACK

func (*RollbackStatementContext) ToStringTree

func (s *RollbackStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type RootContext

type RootContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRootContext

func NewEmptyRootContext() *RootContext

func NewRootContext

func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext

func (*RootContext) Accept

func (s *RootContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*RootContext) AllMINUS

func (s *RootContext) AllMINUS() []antlr.TerminalNode

func (*RootContext) EOF

func (s *RootContext) EOF() antlr.TerminalNode

func (*RootContext) EnterRule

func (s *RootContext) EnterRule(listener antlr.ParseTreeListener)

func (*RootContext) ExitRule

func (s *RootContext) ExitRule(listener antlr.ParseTreeListener)

func (*RootContext) GetParser

func (s *RootContext) GetParser() antlr.Parser

func (*RootContext) GetRuleContext

func (s *RootContext) GetRuleContext() antlr.RuleContext

func (*RootContext) IsRootContext

func (*RootContext) IsRootContext()

func (*RootContext) MINUS

func (s *RootContext) MINUS(i int) antlr.TerminalNode

func (*RootContext) Statements

func (s *RootContext) Statements() IStatementsContext

func (*RootContext) ToStringTree

func (s *RootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type RoutineBodyContext

type RoutineBodyContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRoutineBodyContext

func NewEmptyRoutineBodyContext() *RoutineBodyContext

func NewRoutineBodyContext

func NewRoutineBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoutineBodyContext

func (*RoutineBodyContext) CopyAll

func (s *RoutineBodyContext) CopyAll(ctx *RoutineBodyContext)

func (*RoutineBodyContext) GetParser

func (s *RoutineBodyContext) GetParser() antlr.Parser

func (*RoutineBodyContext) GetRuleContext

func (s *RoutineBodyContext) GetRuleContext() antlr.RuleContext

func (*RoutineBodyContext) IsRoutineBodyContext

func (*RoutineBodyContext) IsRoutineBodyContext()

func (*RoutineBodyContext) ToStringTree

func (s *RoutineBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type RoutineCharacteristicsContext

type RoutineCharacteristicsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRoutineCharacteristicsContext

func NewEmptyRoutineCharacteristicsContext() *RoutineCharacteristicsContext

func NewRoutineCharacteristicsContext

func NewRoutineCharacteristicsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoutineCharacteristicsContext

func (*RoutineCharacteristicsContext) Accept

func (s *RoutineCharacteristicsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*RoutineCharacteristicsContext) DeterministicCharacteristic

func (s *RoutineCharacteristicsContext) DeterministicCharacteristic() IDeterministicCharacteristicContext

func (*RoutineCharacteristicsContext) EnterRule

func (s *RoutineCharacteristicsContext) EnterRule(listener antlr.ParseTreeListener)

func (*RoutineCharacteristicsContext) ExitRule

func (*RoutineCharacteristicsContext) GetParser

func (*RoutineCharacteristicsContext) GetRuleContext

func (s *RoutineCharacteristicsContext) GetRuleContext() antlr.RuleContext

func (*RoutineCharacteristicsContext) IsRoutineCharacteristicsContext

func (*RoutineCharacteristicsContext) IsRoutineCharacteristicsContext()

func (*RoutineCharacteristicsContext) LanguageClause

func (*RoutineCharacteristicsContext) NullCallClause

func (*RoutineCharacteristicsContext) ParameterStyle

func (*RoutineCharacteristicsContext) ToStringTree

func (s *RoutineCharacteristicsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ScalarFunctionCallContext

type ScalarFunctionCallContext struct {
	FunctionCallContext
}

func NewScalarFunctionCallContext

func NewScalarFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ScalarFunctionCallContext

func (*ScalarFunctionCallContext) Accept

func (s *ScalarFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ScalarFunctionCallContext) EnterRule

func (s *ScalarFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*ScalarFunctionCallContext) ExitRule

func (s *ScalarFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*ScalarFunctionCallContext) FunctionArgs

func (*ScalarFunctionCallContext) GetRuleContext

func (s *ScalarFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*ScalarFunctionCallContext) LEFT_ROUND_BRACKET

func (s *ScalarFunctionCallContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*ScalarFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *ScalarFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*ScalarFunctionCallContext) ScalarFunctionName

func (s *ScalarFunctionCallContext) ScalarFunctionName() IScalarFunctionNameContext

type ScalarFunctionNameContext

type ScalarFunctionNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyScalarFunctionNameContext

func NewEmptyScalarFunctionNameContext() *ScalarFunctionNameContext

func NewScalarFunctionNameContext

func NewScalarFunctionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ScalarFunctionNameContext

func (*ScalarFunctionNameContext) ASCII

func (*ScalarFunctionNameContext) Accept

func (s *ScalarFunctionNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ScalarFunctionNameContext) CURDATE

func (*ScalarFunctionNameContext) CURRENT_DATE

func (s *ScalarFunctionNameContext) CURRENT_DATE() antlr.TerminalNode

func (*ScalarFunctionNameContext) CURRENT_TIME

func (s *ScalarFunctionNameContext) CURRENT_TIME() antlr.TerminalNode

func (*ScalarFunctionNameContext) CURRENT_TIMESTAMP

func (s *ScalarFunctionNameContext) CURRENT_TIMESTAMP() antlr.TerminalNode

func (*ScalarFunctionNameContext) CURTIME

func (*ScalarFunctionNameContext) DATE_ADD

func (*ScalarFunctionNameContext) DATE_SUB

func (*ScalarFunctionNameContext) EnterRule

func (s *ScalarFunctionNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*ScalarFunctionNameContext) ExitRule

func (s *ScalarFunctionNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*ScalarFunctionNameContext) FunctionNameBase

func (*ScalarFunctionNameContext) FunctionNameKeyword

func (s *ScalarFunctionNameContext) FunctionNameKeyword() IFunctionNameKeywordContext

func (*ScalarFunctionNameContext) GetParser

func (s *ScalarFunctionNameContext) GetParser() antlr.Parser

func (*ScalarFunctionNameContext) GetRuleContext

func (s *ScalarFunctionNameContext) GetRuleContext() antlr.RuleContext

func (*ScalarFunctionNameContext) IF

func (*ScalarFunctionNameContext) INSERT

func (*ScalarFunctionNameContext) IsScalarFunctionNameContext

func (*ScalarFunctionNameContext) IsScalarFunctionNameContext()

func (*ScalarFunctionNameContext) JAVA_CALL

func (*ScalarFunctionNameContext) LOCALTIME

func (*ScalarFunctionNameContext) LOCALTIMESTAMP

func (s *ScalarFunctionNameContext) LOCALTIMESTAMP() antlr.TerminalNode

func (*ScalarFunctionNameContext) MID

func (*ScalarFunctionNameContext) NOW

func (*ScalarFunctionNameContext) REPLACE

func (*ScalarFunctionNameContext) SUBSTR

func (*ScalarFunctionNameContext) SUBSTRING

func (*ScalarFunctionNameContext) SYSDATE

func (*ScalarFunctionNameContext) TRIM

func (*ScalarFunctionNameContext) ToStringTree

func (s *ScalarFunctionNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ScalarFunctionNameContext) UTC_DATE

func (*ScalarFunctionNameContext) UTC_TIME

func (*ScalarFunctionNameContext) UTC_TIMESTAMP

func (s *ScalarFunctionNameContext) UTC_TIMESTAMP() antlr.TerminalNode

type SchemaIdContext

type SchemaIdContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySchemaIdContext

func NewEmptySchemaIdContext() *SchemaIdContext

func NewSchemaIdContext

func NewSchemaIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SchemaIdContext

func (*SchemaIdContext) Accept

func (s *SchemaIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SchemaIdContext) EnterRule

func (s *SchemaIdContext) EnterRule(listener antlr.ParseTreeListener)

func (*SchemaIdContext) ExitRule

func (s *SchemaIdContext) ExitRule(listener antlr.ParseTreeListener)

func (*SchemaIdContext) GetParser

func (s *SchemaIdContext) GetParser() antlr.Parser

func (*SchemaIdContext) GetRuleContext

func (s *SchemaIdContext) GetRuleContext() antlr.RuleContext

func (*SchemaIdContext) IsSchemaIdContext

func (*SchemaIdContext) IsSchemaIdContext()

func (*SchemaIdContext) Path

func (s *SchemaIdContext) Path() IPathContext

func (*SchemaIdContext) ToStringTree

func (s *SchemaIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SchemaTemplateIdContext

type SchemaTemplateIdContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySchemaTemplateIdContext

func NewEmptySchemaTemplateIdContext() *SchemaTemplateIdContext

func NewSchemaTemplateIdContext

func NewSchemaTemplateIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SchemaTemplateIdContext

func (*SchemaTemplateIdContext) Accept

func (s *SchemaTemplateIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SchemaTemplateIdContext) EnterRule

func (s *SchemaTemplateIdContext) EnterRule(listener antlr.ParseTreeListener)

func (*SchemaTemplateIdContext) ExitRule

func (s *SchemaTemplateIdContext) ExitRule(listener antlr.ParseTreeListener)

func (*SchemaTemplateIdContext) GetParser

func (s *SchemaTemplateIdContext) GetParser() antlr.Parser

func (*SchemaTemplateIdContext) GetRuleContext

func (s *SchemaTemplateIdContext) GetRuleContext() antlr.RuleContext

func (*SchemaTemplateIdContext) IsSchemaTemplateIdContext

func (*SchemaTemplateIdContext) IsSchemaTemplateIdContext()

func (*SchemaTemplateIdContext) ToStringTree

func (s *SchemaTemplateIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*SchemaTemplateIdContext) Uid

type SelectElementContext

type SelectElementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySelectElementContext

func NewEmptySelectElementContext() *SelectElementContext

func NewSelectElementContext

func NewSelectElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectElementContext

func (*SelectElementContext) CopyAll

func (s *SelectElementContext) CopyAll(ctx *SelectElementContext)

func (*SelectElementContext) GetParser

func (s *SelectElementContext) GetParser() antlr.Parser

func (*SelectElementContext) GetRuleContext

func (s *SelectElementContext) GetRuleContext() antlr.RuleContext

func (*SelectElementContext) IsSelectElementContext

func (*SelectElementContext) IsSelectElementContext()

func (*SelectElementContext) ToStringTree

func (s *SelectElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SelectElementsContext

type SelectElementsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySelectElementsContext

func NewEmptySelectElementsContext() *SelectElementsContext

func NewSelectElementsContext

func NewSelectElementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectElementsContext

func (*SelectElementsContext) Accept

func (s *SelectElementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SelectElementsContext) AllCOMMA

func (s *SelectElementsContext) AllCOMMA() []antlr.TerminalNode

func (*SelectElementsContext) AllSelectElement

func (s *SelectElementsContext) AllSelectElement() []ISelectElementContext

func (*SelectElementsContext) COMMA

func (*SelectElementsContext) EnterRule

func (s *SelectElementsContext) EnterRule(listener antlr.ParseTreeListener)

func (*SelectElementsContext) ExitRule

func (s *SelectElementsContext) ExitRule(listener antlr.ParseTreeListener)

func (*SelectElementsContext) GetParser

func (s *SelectElementsContext) GetParser() antlr.Parser

func (*SelectElementsContext) GetRuleContext

func (s *SelectElementsContext) GetRuleContext() antlr.RuleContext

func (*SelectElementsContext) IsSelectElementsContext

func (*SelectElementsContext) IsSelectElementsContext()

func (*SelectElementsContext) SelectElement

func (s *SelectElementsContext) SelectElement(i int) ISelectElementContext

func (*SelectElementsContext) ToStringTree

func (s *SelectElementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SelectExpressionElementContext

type SelectExpressionElementContext struct {
	SelectElementContext
}

func NewSelectExpressionElementContext

func NewSelectExpressionElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectExpressionElementContext

func (*SelectExpressionElementContext) AS

func (*SelectExpressionElementContext) Accept

func (s *SelectExpressionElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SelectExpressionElementContext) EnterRule

func (*SelectExpressionElementContext) ExitRule

func (*SelectExpressionElementContext) Expression

func (*SelectExpressionElementContext) GetRuleContext

func (s *SelectExpressionElementContext) GetRuleContext() antlr.RuleContext

func (*SelectExpressionElementContext) Uid

type SelectQualifierStarElementContext

type SelectQualifierStarElementContext struct {
	SelectElementContext
}

func (*SelectQualifierStarElementContext) Accept

func (s *SelectQualifierStarElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SelectQualifierStarElementContext) DOT

func (*SelectQualifierStarElementContext) EnterRule

func (*SelectQualifierStarElementContext) ExitRule

func (*SelectQualifierStarElementContext) GetRuleContext

func (*SelectQualifierStarElementContext) STAR

func (*SelectQualifierStarElementContext) Uid

type SelectStarElementContext

type SelectStarElementContext struct {
	SelectElementContext
}

func NewSelectStarElementContext

func NewSelectStarElementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SelectStarElementContext

func (*SelectStarElementContext) Accept

func (s *SelectStarElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SelectStarElementContext) EnterRule

func (s *SelectStarElementContext) EnterRule(listener antlr.ParseTreeListener)

func (*SelectStarElementContext) ExitRule

func (s *SelectStarElementContext) ExitRule(listener antlr.ParseTreeListener)

func (*SelectStarElementContext) GetRuleContext

func (s *SelectStarElementContext) GetRuleContext() antlr.RuleContext

func (*SelectStarElementContext) STAR

type SelectStatementContext

type SelectStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySelectStatementContext

func NewEmptySelectStatementContext() *SelectStatementContext

func NewSelectStatementContext

func NewSelectStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectStatementContext

func (*SelectStatementContext) Accept

func (s *SelectStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SelectStatementContext) EnterRule

func (s *SelectStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*SelectStatementContext) ExitRule

func (s *SelectStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*SelectStatementContext) GetParser

func (s *SelectStatementContext) GetParser() antlr.Parser

func (*SelectStatementContext) GetRuleContext

func (s *SelectStatementContext) GetRuleContext() antlr.RuleContext

func (*SelectStatementContext) IsSelectStatementContext

func (*SelectStatementContext) IsSelectStatementContext()

func (*SelectStatementContext) Query

func (*SelectStatementContext) StatementOptions

func (s *SelectStatementContext) StatementOptions() IStatementOptionsContext

func (*SelectStatementContext) ToStringTree

func (s *SelectStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SetAutocommitContext

type SetAutocommitContext struct {
	SetStatementContext
}

func NewSetAutocommitContext

func NewSetAutocommitContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetAutocommitContext

func (*SetAutocommitContext) Accept

func (s *SetAutocommitContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SetAutocommitContext) EnterRule

func (s *SetAutocommitContext) EnterRule(listener antlr.ParseTreeListener)

func (*SetAutocommitContext) ExitRule

func (s *SetAutocommitContext) ExitRule(listener antlr.ParseTreeListener)

func (*SetAutocommitContext) GetRuleContext

func (s *SetAutocommitContext) GetRuleContext() antlr.RuleContext

func (*SetAutocommitContext) SetAutocommitStatement

func (s *SetAutocommitContext) SetAutocommitStatement() ISetAutocommitStatementContext

type SetAutocommitStatementContext

type SetAutocommitStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySetAutocommitStatementContext

func NewEmptySetAutocommitStatementContext() *SetAutocommitStatementContext

func NewSetAutocommitStatementContext

func NewSetAutocommitStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetAutocommitStatementContext

func (*SetAutocommitStatementContext) AUTOCOMMIT

func (*SetAutocommitStatementContext) Accept

func (s *SetAutocommitStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SetAutocommitStatementContext) EQUAL_SYMBOL

func (*SetAutocommitStatementContext) EnterRule

func (s *SetAutocommitStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*SetAutocommitStatementContext) ExitRule

func (*SetAutocommitStatementContext) GetAutocommitValue

func (s *SetAutocommitStatementContext) GetAutocommitValue() antlr.Token

func (*SetAutocommitStatementContext) GetParser

func (*SetAutocommitStatementContext) GetRuleContext

func (s *SetAutocommitStatementContext) GetRuleContext() antlr.RuleContext

func (*SetAutocommitStatementContext) IsSetAutocommitStatementContext

func (*SetAutocommitStatementContext) IsSetAutocommitStatementContext()

func (*SetAutocommitStatementContext) OFF

func (*SetAutocommitStatementContext) ON

func (*SetAutocommitStatementContext) SET

func (*SetAutocommitStatementContext) SetAutocommitValue

func (s *SetAutocommitStatementContext) SetAutocommitValue(v antlr.Token)

func (*SetAutocommitStatementContext) ToStringTree

func (s *SetAutocommitStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SetCharsetContext

type SetCharsetContext struct {
	SetStatementContext
}

func NewSetCharsetContext

func NewSetCharsetContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetCharsetContext

func (*SetCharsetContext) Accept

func (s *SetCharsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SetCharsetContext) CharSet

func (s *SetCharsetContext) CharSet() ICharSetContext

func (*SetCharsetContext) CharsetName

func (s *SetCharsetContext) CharsetName() ICharsetNameContext

func (*SetCharsetContext) DEFAULT

func (s *SetCharsetContext) DEFAULT() antlr.TerminalNode

func (*SetCharsetContext) EnterRule

func (s *SetCharsetContext) EnterRule(listener antlr.ParseTreeListener)

func (*SetCharsetContext) ExitRule

func (s *SetCharsetContext) ExitRule(listener antlr.ParseTreeListener)

func (*SetCharsetContext) GetRuleContext

func (s *SetCharsetContext) GetRuleContext() antlr.RuleContext

func (*SetCharsetContext) SET

type SetNamesContext

type SetNamesContext struct {
	SetStatementContext
}

func NewSetNamesContext

func NewSetNamesContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetNamesContext

func (*SetNamesContext) Accept

func (s *SetNamesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SetNamesContext) COLLATE

func (s *SetNamesContext) COLLATE() antlr.TerminalNode

func (*SetNamesContext) CharsetName

func (s *SetNamesContext) CharsetName() ICharsetNameContext

func (*SetNamesContext) CollationName

func (s *SetNamesContext) CollationName() ICollationNameContext

func (*SetNamesContext) DEFAULT

func (s *SetNamesContext) DEFAULT() antlr.TerminalNode

func (*SetNamesContext) EnterRule

func (s *SetNamesContext) EnterRule(listener antlr.ParseTreeListener)

func (*SetNamesContext) ExitRule

func (s *SetNamesContext) ExitRule(listener antlr.ParseTreeListener)

func (*SetNamesContext) GetRuleContext

func (s *SetNamesContext) GetRuleContext() antlr.RuleContext

func (*SetNamesContext) NAMES

func (s *SetNamesContext) NAMES() antlr.TerminalNode

func (*SetNamesContext) SET

type SetNewValueInsideTriggerContext

type SetNewValueInsideTriggerContext struct {
	SetStatementContext
}

func NewSetNewValueInsideTriggerContext

func NewSetNewValueInsideTriggerContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetNewValueInsideTriggerContext

func (*SetNewValueInsideTriggerContext) Accept

func (s *SetNewValueInsideTriggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SetNewValueInsideTriggerContext) AllCOMMA

func (*SetNewValueInsideTriggerContext) AllEQUAL_SYMBOL

func (s *SetNewValueInsideTriggerContext) AllEQUAL_SYMBOL() []antlr.TerminalNode

func (*SetNewValueInsideTriggerContext) AllExpression

func (*SetNewValueInsideTriggerContext) AllFullId

func (*SetNewValueInsideTriggerContext) AllVAR_ASSIGN

func (s *SetNewValueInsideTriggerContext) AllVAR_ASSIGN() []antlr.TerminalNode

func (*SetNewValueInsideTriggerContext) COMMA

func (*SetNewValueInsideTriggerContext) EQUAL_SYMBOL

func (*SetNewValueInsideTriggerContext) EnterRule

func (*SetNewValueInsideTriggerContext) ExitRule

func (*SetNewValueInsideTriggerContext) Expression

func (*SetNewValueInsideTriggerContext) FullId

func (*SetNewValueInsideTriggerContext) GetRuleContext

func (*SetNewValueInsideTriggerContext) SET

func (*SetNewValueInsideTriggerContext) VAR_ASSIGN

type SetQueryContext

type SetQueryContext struct {
	QueryExpressionBodyContext
	// contains filtered or unexported fields
}

func NewSetQueryContext

func NewSetQueryContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetQueryContext

func (*SetQueryContext) ALL

func (*SetQueryContext) Accept

func (s *SetQueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SetQueryContext) AllQueryExpressionBody

func (s *SetQueryContext) AllQueryExpressionBody() []IQueryExpressionBodyContext

func (*SetQueryContext) DISTINCT

func (s *SetQueryContext) DISTINCT() antlr.TerminalNode

func (*SetQueryContext) EnterRule

func (s *SetQueryContext) EnterRule(listener antlr.ParseTreeListener)

func (*SetQueryContext) ExitRule

func (s *SetQueryContext) ExitRule(listener antlr.ParseTreeListener)

func (*SetQueryContext) GetLeft

func (*SetQueryContext) GetOperator

func (s *SetQueryContext) GetOperator() antlr.Token

func (*SetQueryContext) GetQuantifier

func (s *SetQueryContext) GetQuantifier() antlr.Token

func (*SetQueryContext) GetRight

func (*SetQueryContext) GetRuleContext

func (s *SetQueryContext) GetRuleContext() antlr.RuleContext

func (*SetQueryContext) QueryExpressionBody

func (s *SetQueryContext) QueryExpressionBody(i int) IQueryExpressionBodyContext

func (*SetQueryContext) SetLeft

func (*SetQueryContext) SetOperator

func (s *SetQueryContext) SetOperator(v antlr.Token)

func (*SetQueryContext) SetQuantifier

func (s *SetQueryContext) SetQuantifier(v antlr.Token)

func (*SetQueryContext) SetRight

func (*SetQueryContext) UNION

func (s *SetQueryContext) UNION() antlr.TerminalNode

type SetStatementContext

type SetStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySetStatementContext

func NewEmptySetStatementContext() *SetStatementContext

func NewSetStatementContext

func NewSetStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetStatementContext

func (*SetStatementContext) CopyAll

func (s *SetStatementContext) CopyAll(ctx *SetStatementContext)

func (*SetStatementContext) GetParser

func (s *SetStatementContext) GetParser() antlr.Parser

func (*SetStatementContext) GetRuleContext

func (s *SetStatementContext) GetRuleContext() antlr.RuleContext

func (*SetStatementContext) IsSetStatementContext

func (*SetStatementContext) IsSetStatementContext()

func (*SetStatementContext) ToStringTree

func (s *SetStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SetTransactionContext

type SetTransactionContext struct {
	SetStatementContext
}

func NewSetTransactionContext

func NewSetTransactionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetTransactionContext

func (*SetTransactionContext) Accept

func (s *SetTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SetTransactionContext) EnterRule

func (s *SetTransactionContext) EnterRule(listener antlr.ParseTreeListener)

func (*SetTransactionContext) ExitRule

func (s *SetTransactionContext) ExitRule(listener antlr.ParseTreeListener)

func (*SetTransactionContext) GetRuleContext

func (s *SetTransactionContext) GetRuleContext() antlr.RuleContext

func (*SetTransactionContext) SetTransactionStatement

func (s *SetTransactionContext) SetTransactionStatement() ISetTransactionStatementContext

type SetTransactionStatementContext

type SetTransactionStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySetTransactionStatementContext

func NewEmptySetTransactionStatementContext() *SetTransactionStatementContext

func NewSetTransactionStatementContext

func NewSetTransactionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetTransactionStatementContext

func (*SetTransactionStatementContext) Accept

func (s *SetTransactionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SetTransactionStatementContext) AllCOMMA

func (*SetTransactionStatementContext) AllTransactionOption

func (s *SetTransactionStatementContext) AllTransactionOption() []ITransactionOptionContext

func (*SetTransactionStatementContext) COMMA

func (*SetTransactionStatementContext) EnterRule

func (*SetTransactionStatementContext) ExitRule

func (*SetTransactionStatementContext) GLOBAL

func (*SetTransactionStatementContext) GetParser

func (*SetTransactionStatementContext) GetRuleContext

func (s *SetTransactionStatementContext) GetRuleContext() antlr.RuleContext

func (*SetTransactionStatementContext) GetTransactionContext

func (s *SetTransactionStatementContext) GetTransactionContext() antlr.Token

func (*SetTransactionStatementContext) IsSetTransactionStatementContext

func (*SetTransactionStatementContext) IsSetTransactionStatementContext()

func (*SetTransactionStatementContext) SESSION

func (*SetTransactionStatementContext) SET

func (*SetTransactionStatementContext) SetTransactionContext

func (s *SetTransactionStatementContext) SetTransactionContext(v antlr.Token)

func (*SetTransactionStatementContext) TRANSACTION

func (*SetTransactionStatementContext) ToStringTree

func (s *SetTransactionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*SetTransactionStatementContext) TransactionOption

type SetVariableContext

type SetVariableContext struct {
	SetStatementContext
}

func NewSetVariableContext

func NewSetVariableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SetVariableContext

func (*SetVariableContext) Accept

func (s *SetVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SetVariableContext) AllCOMMA

func (s *SetVariableContext) AllCOMMA() []antlr.TerminalNode

func (*SetVariableContext) AllEQUAL_SYMBOL

func (s *SetVariableContext) AllEQUAL_SYMBOL() []antlr.TerminalNode

func (*SetVariableContext) AllExpression

func (s *SetVariableContext) AllExpression() []IExpressionContext

func (*SetVariableContext) AllVAR_ASSIGN

func (s *SetVariableContext) AllVAR_ASSIGN() []antlr.TerminalNode

func (*SetVariableContext) AllVariableClause

func (s *SetVariableContext) AllVariableClause() []IVariableClauseContext

func (*SetVariableContext) COMMA

func (*SetVariableContext) EQUAL_SYMBOL

func (s *SetVariableContext) EQUAL_SYMBOL(i int) antlr.TerminalNode

func (*SetVariableContext) EnterRule

func (s *SetVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*SetVariableContext) ExitRule

func (s *SetVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*SetVariableContext) Expression

func (s *SetVariableContext) Expression(i int) IExpressionContext

func (*SetVariableContext) GetRuleContext

func (s *SetVariableContext) GetRuleContext() antlr.RuleContext

func (*SetVariableContext) SET

func (*SetVariableContext) VAR_ASSIGN

func (s *SetVariableContext) VAR_ASSIGN(i int) antlr.TerminalNode

func (*SetVariableContext) VariableClause

func (s *SetVariableContext) VariableClause(i int) IVariableClauseContext

type ShowDatabasesStatementContext

type ShowDatabasesStatementContext struct {
	ShowStatementContext
}

func NewShowDatabasesStatementContext

func NewShowDatabasesStatementContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ShowDatabasesStatementContext

func (*ShowDatabasesStatementContext) Accept

func (s *ShowDatabasesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ShowDatabasesStatementContext) DATABASES

func (*ShowDatabasesStatementContext) EnterRule

func (s *ShowDatabasesStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*ShowDatabasesStatementContext) ExitRule

func (*ShowDatabasesStatementContext) GetRuleContext

func (s *ShowDatabasesStatementContext) GetRuleContext() antlr.RuleContext

func (*ShowDatabasesStatementContext) PREFIX

func (*ShowDatabasesStatementContext) Path

func (*ShowDatabasesStatementContext) SHOW

func (*ShowDatabasesStatementContext) WITH

type ShowSchemaTemplatesStatementContext

type ShowSchemaTemplatesStatementContext struct {
	ShowStatementContext
}

func (*ShowSchemaTemplatesStatementContext) Accept

func (s *ShowSchemaTemplatesStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ShowSchemaTemplatesStatementContext) EnterRule

func (*ShowSchemaTemplatesStatementContext) ExitRule

func (*ShowSchemaTemplatesStatementContext) GetRuleContext

func (*ShowSchemaTemplatesStatementContext) SCHEMA

func (*ShowSchemaTemplatesStatementContext) SHOW

func (*ShowSchemaTemplatesStatementContext) TEMPLATES

type ShowStatementContext

type ShowStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyShowStatementContext

func NewEmptyShowStatementContext() *ShowStatementContext

func NewShowStatementContext

func NewShowStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowStatementContext

func (*ShowStatementContext) CopyAll

func (s *ShowStatementContext) CopyAll(ctx *ShowStatementContext)

func (*ShowStatementContext) GetParser

func (s *ShowStatementContext) GetParser() antlr.Parser

func (*ShowStatementContext) GetRuleContext

func (s *ShowStatementContext) GetRuleContext() antlr.RuleContext

func (*ShowStatementContext) IsShowStatementContext

func (*ShowStatementContext) IsShowStatementContext()

func (*ShowStatementContext) ToStringTree

func (s *ShowStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SimpleDataTypeContext

type SimpleDataTypeContext struct {
	DataTypeContext
	// contains filtered or unexported fields
}

func NewSimpleDataTypeContext

func NewSimpleDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleDataTypeContext

func (*SimpleDataTypeContext) Accept

func (s *SimpleDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SimpleDataTypeContext) BOOL

func (*SimpleDataTypeContext) BOOLEAN

func (*SimpleDataTypeContext) DATE

func (*SimpleDataTypeContext) EnterRule

func (s *SimpleDataTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*SimpleDataTypeContext) ExitRule

func (s *SimpleDataTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*SimpleDataTypeContext) GetRuleContext

func (s *SimpleDataTypeContext) GetRuleContext() antlr.RuleContext

func (*SimpleDataTypeContext) GetTypeName

func (s *SimpleDataTypeContext) GetTypeName() antlr.Token

func (*SimpleDataTypeContext) LONGBLOB

func (*SimpleDataTypeContext) MEDIUMBLOB

func (s *SimpleDataTypeContext) MEDIUMBLOB() antlr.TerminalNode

func (*SimpleDataTypeContext) SERIAL

func (*SimpleDataTypeContext) SetTypeName

func (s *SimpleDataTypeContext) SetTypeName(v antlr.Token)

func (*SimpleDataTypeContext) TINYBLOB

type SimpleDescribeSchemaStatementContext

type SimpleDescribeSchemaStatementContext struct {
	SimpleDescribeStatementContext
	// contains filtered or unexported fields
}

func (*SimpleDescribeSchemaStatementContext) Accept

func (s *SimpleDescribeSchemaStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SimpleDescribeSchemaStatementContext) DESC

func (*SimpleDescribeSchemaStatementContext) DESCRIBE

func (*SimpleDescribeSchemaStatementContext) EXPLAIN

func (*SimpleDescribeSchemaStatementContext) EnterRule

func (*SimpleDescribeSchemaStatementContext) ExitRule

func (*SimpleDescribeSchemaStatementContext) GetCommand

func (*SimpleDescribeSchemaStatementContext) GetRuleContext

func (*SimpleDescribeSchemaStatementContext) SCHEMA

func (*SimpleDescribeSchemaStatementContext) SchemaId

func (*SimpleDescribeSchemaStatementContext) SetCommand

type SimpleDescribeSchemaTemplateStatementContext

type SimpleDescribeSchemaTemplateStatementContext struct {
	SimpleDescribeStatementContext
	// contains filtered or unexported fields
}

func (*SimpleDescribeSchemaTemplateStatementContext) Accept

func (*SimpleDescribeSchemaTemplateStatementContext) DESC

func (*SimpleDescribeSchemaTemplateStatementContext) DESCRIBE

func (*SimpleDescribeSchemaTemplateStatementContext) EXPLAIN

func (*SimpleDescribeSchemaTemplateStatementContext) EnterRule

func (*SimpleDescribeSchemaTemplateStatementContext) ExitRule

func (*SimpleDescribeSchemaTemplateStatementContext) GetCommand

func (*SimpleDescribeSchemaTemplateStatementContext) GetRuleContext

func (*SimpleDescribeSchemaTemplateStatementContext) SCHEMA

func (*SimpleDescribeSchemaTemplateStatementContext) SetCommand

func (*SimpleDescribeSchemaTemplateStatementContext) TEMPLATE

func (*SimpleDescribeSchemaTemplateStatementContext) Uid

type SimpleDescribeStatementContext

type SimpleDescribeStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySimpleDescribeStatementContext

func NewEmptySimpleDescribeStatementContext() *SimpleDescribeStatementContext

func NewSimpleDescribeStatementContext

func NewSimpleDescribeStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleDescribeStatementContext

func (*SimpleDescribeStatementContext) CopyAll

func (*SimpleDescribeStatementContext) GetParser

func (*SimpleDescribeStatementContext) GetRuleContext

func (s *SimpleDescribeStatementContext) GetRuleContext() antlr.RuleContext

func (*SimpleDescribeStatementContext) IsSimpleDescribeStatementContext

func (*SimpleDescribeStatementContext) IsSimpleDescribeStatementContext()

func (*SimpleDescribeStatementContext) ToStringTree

func (s *SimpleDescribeStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SimpleFunctionCallContext

type SimpleFunctionCallContext struct {
	SpecificFunctionContext
}

func NewSimpleFunctionCallContext

func NewSimpleFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleFunctionCallContext

func (*SimpleFunctionCallContext) Accept

func (s *SimpleFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SimpleFunctionCallContext) CURRENT_DATE

func (s *SimpleFunctionCallContext) CURRENT_DATE() antlr.TerminalNode

func (*SimpleFunctionCallContext) CURRENT_TIME

func (s *SimpleFunctionCallContext) CURRENT_TIME() antlr.TerminalNode

func (*SimpleFunctionCallContext) CURRENT_TIMESTAMP

func (s *SimpleFunctionCallContext) CURRENT_TIMESTAMP() antlr.TerminalNode

func (*SimpleFunctionCallContext) CURRENT_USER

func (s *SimpleFunctionCallContext) CURRENT_USER() antlr.TerminalNode

func (*SimpleFunctionCallContext) EnterRule

func (s *SimpleFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*SimpleFunctionCallContext) ExitRule

func (s *SimpleFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*SimpleFunctionCallContext) GetRuleContext

func (s *SimpleFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*SimpleFunctionCallContext) LEFT_ROUND_BRACKET

func (s *SimpleFunctionCallContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*SimpleFunctionCallContext) LOCALTIME

func (*SimpleFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *SimpleFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

type SimpleIdContext

type SimpleIdContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySimpleIdContext

func NewEmptySimpleIdContext() *SimpleIdContext

func NewSimpleIdContext

func NewSimpleIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpleIdContext

func (*SimpleIdContext) Accept

func (s *SimpleIdContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SimpleIdContext) CharsetNameBase

func (s *SimpleIdContext) CharsetNameBase() ICharsetNameBaseContext

func (*SimpleIdContext) EnterRule

func (s *SimpleIdContext) EnterRule(listener antlr.ParseTreeListener)

func (*SimpleIdContext) ExitRule

func (s *SimpleIdContext) ExitRule(listener antlr.ParseTreeListener)

func (*SimpleIdContext) FunctionNameBase

func (s *SimpleIdContext) FunctionNameBase() IFunctionNameBaseContext

func (*SimpleIdContext) GetParser

func (s *SimpleIdContext) GetParser() antlr.Parser

func (*SimpleIdContext) GetRuleContext

func (s *SimpleIdContext) GetRuleContext() antlr.RuleContext

func (*SimpleIdContext) ID

func (*SimpleIdContext) IntervalTypeBase

func (s *SimpleIdContext) IntervalTypeBase() IIntervalTypeBaseContext

func (*SimpleIdContext) IsSimpleIdContext

func (*SimpleIdContext) IsSimpleIdContext()

func (*SimpleIdContext) KeywordsCanBeId

func (s *SimpleIdContext) KeywordsCanBeId() IKeywordsCanBeIdContext

func (*SimpleIdContext) ToStringTree

func (s *SimpleIdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SimpleTableContext

type SimpleTableContext struct {
	QueryTermContext
}

func NewSimpleTableContext

func NewSimpleTableContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SimpleTableContext

func (*SimpleTableContext) Accept

func (s *SimpleTableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SimpleTableContext) DISTINCT

func (s *SimpleTableContext) DISTINCT() antlr.TerminalNode

func (*SimpleTableContext) EnterRule

func (s *SimpleTableContext) EnterRule(listener antlr.ParseTreeListener)

func (*SimpleTableContext) ExitRule

func (s *SimpleTableContext) ExitRule(listener antlr.ParseTreeListener)

func (*SimpleTableContext) FromClause

func (s *SimpleTableContext) FromClause() IFromClauseContext

func (*SimpleTableContext) GetRuleContext

func (s *SimpleTableContext) GetRuleContext() antlr.RuleContext

func (*SimpleTableContext) GroupByClause

func (s *SimpleTableContext) GroupByClause() IGroupByClauseContext

func (*SimpleTableContext) HavingClause

func (s *SimpleTableContext) HavingClause() IHavingClauseContext

func (*SimpleTableContext) LimitClause

func (s *SimpleTableContext) LimitClause() ILimitClauseContext

func (*SimpleTableContext) OrderByClause

func (s *SimpleTableContext) OrderByClause() IOrderByClauseContext

func (*SimpleTableContext) QualifyClause

func (s *SimpleTableContext) QualifyClause() IQualifyClauseContext

func (*SimpleTableContext) SELECT

func (*SimpleTableContext) SelectElements

func (s *SimpleTableContext) SelectElements() ISelectElementsContext

type SpatialDataTypeContext

type SpatialDataTypeContext struct {
	DataTypeContext
	// contains filtered or unexported fields
}

func NewSpatialDataTypeContext

func NewSpatialDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SpatialDataTypeContext

func (*SpatialDataTypeContext) Accept

func (s *SpatialDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SpatialDataTypeContext) EnterRule

func (s *SpatialDataTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*SpatialDataTypeContext) ExitRule

func (s *SpatialDataTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*SpatialDataTypeContext) GEOMCOLLECTION

func (s *SpatialDataTypeContext) GEOMCOLLECTION() antlr.TerminalNode

func (*SpatialDataTypeContext) GEOMETRY

func (*SpatialDataTypeContext) GEOMETRYCOLLECTION

func (s *SpatialDataTypeContext) GEOMETRYCOLLECTION() antlr.TerminalNode

func (*SpatialDataTypeContext) GetRuleContext

func (s *SpatialDataTypeContext) GetRuleContext() antlr.RuleContext

func (*SpatialDataTypeContext) GetTypeName

func (s *SpatialDataTypeContext) GetTypeName() antlr.Token

func (*SpatialDataTypeContext) JSON

func (*SpatialDataTypeContext) LINESTRING

func (s *SpatialDataTypeContext) LINESTRING() antlr.TerminalNode

func (*SpatialDataTypeContext) MULTILINESTRING

func (s *SpatialDataTypeContext) MULTILINESTRING() antlr.TerminalNode

func (*SpatialDataTypeContext) MULTIPOINT

func (s *SpatialDataTypeContext) MULTIPOINT() antlr.TerminalNode

func (*SpatialDataTypeContext) MULTIPOLYGON

func (s *SpatialDataTypeContext) MULTIPOLYGON() antlr.TerminalNode

func (*SpatialDataTypeContext) POINT

func (*SpatialDataTypeContext) POLYGON

func (*SpatialDataTypeContext) SetTypeName

func (s *SpatialDataTypeContext) SetTypeName(v antlr.Token)

type SpecificFunctionCallContext

type SpecificFunctionCallContext struct {
	FunctionCallContext
}

func NewSpecificFunctionCallContext

func NewSpecificFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SpecificFunctionCallContext

func (*SpecificFunctionCallContext) Accept

func (s *SpecificFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SpecificFunctionCallContext) EnterRule

func (s *SpecificFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*SpecificFunctionCallContext) ExitRule

func (s *SpecificFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*SpecificFunctionCallContext) GetRuleContext

func (s *SpecificFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*SpecificFunctionCallContext) SpecificFunction

type SpecificFunctionContext

type SpecificFunctionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySpecificFunctionContext

func NewEmptySpecificFunctionContext() *SpecificFunctionContext

func NewSpecificFunctionContext

func NewSpecificFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SpecificFunctionContext

func (*SpecificFunctionContext) CopyAll

func (*SpecificFunctionContext) GetParser

func (s *SpecificFunctionContext) GetParser() antlr.Parser

func (*SpecificFunctionContext) GetRuleContext

func (s *SpecificFunctionContext) GetRuleContext() antlr.RuleContext

func (*SpecificFunctionContext) IsSpecificFunctionContext

func (*SpecificFunctionContext) IsSpecificFunctionContext()

func (*SpecificFunctionContext) ToStringTree

func (s *SpecificFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SqlInvokedFunctionContext

type SqlInvokedFunctionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySqlInvokedFunctionContext

func NewEmptySqlInvokedFunctionContext() *SqlInvokedFunctionContext

func NewSqlInvokedFunctionContext

func NewSqlInvokedFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SqlInvokedFunctionContext

func (*SqlInvokedFunctionContext) Accept

func (s *SqlInvokedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SqlInvokedFunctionContext) EnterRule

func (s *SqlInvokedFunctionContext) EnterRule(listener antlr.ParseTreeListener)

func (*SqlInvokedFunctionContext) ExitRule

func (s *SqlInvokedFunctionContext) ExitRule(listener antlr.ParseTreeListener)

func (*SqlInvokedFunctionContext) FunctionSpecification

func (s *SqlInvokedFunctionContext) FunctionSpecification() IFunctionSpecificationContext

func (*SqlInvokedFunctionContext) GetParser

func (s *SqlInvokedFunctionContext) GetParser() antlr.Parser

func (*SqlInvokedFunctionContext) GetRuleContext

func (s *SqlInvokedFunctionContext) GetRuleContext() antlr.RuleContext

func (*SqlInvokedFunctionContext) IsSqlInvokedFunctionContext

func (*SqlInvokedFunctionContext) IsSqlInvokedFunctionContext()

func (*SqlInvokedFunctionContext) RoutineBody

func (*SqlInvokedFunctionContext) ToStringTree

func (s *SqlInvokedFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SqlParameterDeclarationContext

type SqlParameterDeclarationContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySqlParameterDeclarationContext

func NewEmptySqlParameterDeclarationContext() *SqlParameterDeclarationContext

func NewSqlParameterDeclarationContext

func NewSqlParameterDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SqlParameterDeclarationContext

func (*SqlParameterDeclarationContext) Accept

func (s *SqlParameterDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SqlParameterDeclarationContext) DEFAULT

func (*SqlParameterDeclarationContext) EnterRule

func (*SqlParameterDeclarationContext) ExitRule

func (*SqlParameterDeclarationContext) Expression

func (*SqlParameterDeclarationContext) FunctionColumnType

func (*SqlParameterDeclarationContext) GetParameterDefault

func (s *SqlParameterDeclarationContext) GetParameterDefault() IExpressionContext

func (*SqlParameterDeclarationContext) GetParameterType

func (*SqlParameterDeclarationContext) GetParser

func (*SqlParameterDeclarationContext) GetRuleContext

func (s *SqlParameterDeclarationContext) GetRuleContext() antlr.RuleContext

func (*SqlParameterDeclarationContext) GetSqlParameterName

func (s *SqlParameterDeclarationContext) GetSqlParameterName() IUidContext

func (*SqlParameterDeclarationContext) IsSqlParameterDeclarationContext

func (*SqlParameterDeclarationContext) IsSqlParameterDeclarationContext()

func (*SqlParameterDeclarationContext) ParameterMode

func (*SqlParameterDeclarationContext) SetParameterDefault

func (s *SqlParameterDeclarationContext) SetParameterDefault(v IExpressionContext)

func (*SqlParameterDeclarationContext) SetParameterType

func (*SqlParameterDeclarationContext) SetSqlParameterName

func (s *SqlParameterDeclarationContext) SetSqlParameterName(v IUidContext)

func (*SqlParameterDeclarationContext) ToStringTree

func (s *SqlParameterDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*SqlParameterDeclarationContext) Uid

type SqlParameterDeclarationListContext

type SqlParameterDeclarationListContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySqlParameterDeclarationListContext

func NewEmptySqlParameterDeclarationListContext() *SqlParameterDeclarationListContext

func NewSqlParameterDeclarationListContext

func NewSqlParameterDeclarationListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SqlParameterDeclarationListContext

func (*SqlParameterDeclarationListContext) Accept

func (s *SqlParameterDeclarationListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SqlParameterDeclarationListContext) EnterRule

func (*SqlParameterDeclarationListContext) ExitRule

func (*SqlParameterDeclarationListContext) GetParser

func (*SqlParameterDeclarationListContext) GetRuleContext

func (*SqlParameterDeclarationListContext) IsSqlParameterDeclarationListContext

func (*SqlParameterDeclarationListContext) IsSqlParameterDeclarationListContext()

func (*SqlParameterDeclarationListContext) LEFT_ROUND_BRACKET

func (s *SqlParameterDeclarationListContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*SqlParameterDeclarationListContext) RIGHT_ROUND_BRACKET

func (s *SqlParameterDeclarationListContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*SqlParameterDeclarationListContext) SqlParameterDeclarations

func (*SqlParameterDeclarationListContext) ToStringTree

func (s *SqlParameterDeclarationListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SqlParameterDeclarationsContext

type SqlParameterDeclarationsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySqlParameterDeclarationsContext

func NewEmptySqlParameterDeclarationsContext() *SqlParameterDeclarationsContext

func NewSqlParameterDeclarationsContext

func NewSqlParameterDeclarationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SqlParameterDeclarationsContext

func (*SqlParameterDeclarationsContext) Accept

func (s *SqlParameterDeclarationsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SqlParameterDeclarationsContext) AllCOMMA

func (*SqlParameterDeclarationsContext) AllSqlParameterDeclaration

func (s *SqlParameterDeclarationsContext) AllSqlParameterDeclaration() []ISqlParameterDeclarationContext

func (*SqlParameterDeclarationsContext) COMMA

func (*SqlParameterDeclarationsContext) EnterRule

func (*SqlParameterDeclarationsContext) ExitRule

func (*SqlParameterDeclarationsContext) GetParser

func (*SqlParameterDeclarationsContext) GetRuleContext

func (*SqlParameterDeclarationsContext) IsSqlParameterDeclarationsContext

func (*SqlParameterDeclarationsContext) IsSqlParameterDeclarationsContext()

func (*SqlParameterDeclarationsContext) SqlParameterDeclaration

func (*SqlParameterDeclarationsContext) ToStringTree

func (s *SqlParameterDeclarationsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StartTransactionContext

type StartTransactionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStartTransactionContext

func NewEmptyStartTransactionContext() *StartTransactionContext

func NewStartTransactionContext

func NewStartTransactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StartTransactionContext

func (*StartTransactionContext) Accept

func (s *StartTransactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StartTransactionContext) EnterRule

func (s *StartTransactionContext) EnterRule(listener antlr.ParseTreeListener)

func (*StartTransactionContext) ExitRule

func (s *StartTransactionContext) ExitRule(listener antlr.ParseTreeListener)

func (*StartTransactionContext) GetParser

func (s *StartTransactionContext) GetParser() antlr.Parser

func (*StartTransactionContext) GetRuleContext

func (s *StartTransactionContext) GetRuleContext() antlr.RuleContext

func (*StartTransactionContext) IsStartTransactionContext

func (*StartTransactionContext) IsStartTransactionContext()

func (*StartTransactionContext) START

func (*StartTransactionContext) TRANSACTION

func (s *StartTransactionContext) TRANSACTION() antlr.TerminalNode

func (*StartTransactionContext) ToStringTree

func (s *StartTransactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StatementBodyContext

type StatementBodyContext struct {
	RoutineBodyContext
}

func NewStatementBodyContext

func NewStatementBodyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StatementBodyContext

func (*StatementBodyContext) AS

func (*StatementBodyContext) Accept

func (s *StatementBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StatementBodyContext) EnterRule

func (s *StatementBodyContext) EnterRule(listener antlr.ParseTreeListener)

func (*StatementBodyContext) ExitRule

func (s *StatementBodyContext) ExitRule(listener antlr.ParseTreeListener)

func (*StatementBodyContext) GetRuleContext

func (s *StatementBodyContext) GetRuleContext() antlr.RuleContext

func (*StatementBodyContext) QueryTerm

func (s *StatementBodyContext) QueryTerm() IQueryTermContext

type StatementContext

type StatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStatementContext

func NewEmptyStatementContext() *StatementContext

func NewStatementContext

func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext

func (*StatementContext) Accept

func (s *StatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StatementContext) AdministrationStatement

func (s *StatementContext) AdministrationStatement() IAdministrationStatementContext

func (*StatementContext) DdlStatement

func (s *StatementContext) DdlStatement() IDdlStatementContext

func (*StatementContext) DmlStatement

func (s *StatementContext) DmlStatement() IDmlStatementContext

func (*StatementContext) EnterRule

func (s *StatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*StatementContext) ExitRule

func (s *StatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*StatementContext) GetParser

func (s *StatementContext) GetParser() antlr.Parser

func (*StatementContext) GetRuleContext

func (s *StatementContext) GetRuleContext() antlr.RuleContext

func (*StatementContext) IsStatementContext

func (*StatementContext) IsStatementContext()

func (*StatementContext) PreparedStatement

func (s *StatementContext) PreparedStatement() IPreparedStatementContext

func (*StatementContext) SelectStatement

func (s *StatementContext) SelectStatement() ISelectStatementContext

func (*StatementContext) ToStringTree

func (s *StatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*StatementContext) TransactionStatement

func (s *StatementContext) TransactionStatement() ITransactionStatementContext

func (*StatementContext) UtilityStatement

func (s *StatementContext) UtilityStatement() IUtilityStatementContext

type StatementOptionContext

type StatementOptionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStatementOptionContext

func NewEmptyStatementOptionContext() *StatementOptionContext

func NewStatementOptionContext

func NewStatementOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementOptionContext

func (*StatementOptionContext) Accept

func (s *StatementOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StatementOptionContext) DEEP

func (*StatementOptionContext) DRY

func (*StatementOptionContext) EnterRule

func (s *StatementOptionContext) EnterRule(listener antlr.ParseTreeListener)

func (*StatementOptionContext) ExitRule

func (s *StatementOptionContext) ExitRule(listener antlr.ParseTreeListener)

func (*StatementOptionContext) GetParser

func (s *StatementOptionContext) GetParser() antlr.Parser

func (*StatementOptionContext) GetRuleContext

func (s *StatementOptionContext) GetRuleContext() antlr.RuleContext

func (*StatementOptionContext) ISOLATION

func (s *StatementOptionContext) ISOLATION() antlr.TerminalNode

func (*StatementOptionContext) IsStatementOptionContext

func (*StatementOptionContext) IsStatementOptionContext()

func (*StatementOptionContext) LEVEL

func (*StatementOptionContext) LOG

func (*StatementOptionContext) NOCACHE

func (*StatementOptionContext) PLAN

func (*StatementOptionContext) QUERY

func (*StatementOptionContext) RIGHT

func (*StatementOptionContext) RUN

func (*StatementOptionContext) SNAPSHOT

func (*StatementOptionContext) ToStringTree

func (s *StatementOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StatementOptionsContext

type StatementOptionsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStatementOptionsContext

func NewEmptyStatementOptionsContext() *StatementOptionsContext

func NewStatementOptionsContext

func NewStatementOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementOptionsContext

func (*StatementOptionsContext) Accept

func (s *StatementOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StatementOptionsContext) AllCOMMA

func (s *StatementOptionsContext) AllCOMMA() []antlr.TerminalNode

func (*StatementOptionsContext) AllStatementOption

func (s *StatementOptionsContext) AllStatementOption() []IStatementOptionContext

func (*StatementOptionsContext) COMMA

func (*StatementOptionsContext) EnterRule

func (s *StatementOptionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*StatementOptionsContext) ExitRule

func (s *StatementOptionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*StatementOptionsContext) GetParser

func (s *StatementOptionsContext) GetParser() antlr.Parser

func (*StatementOptionsContext) GetRuleContext

func (s *StatementOptionsContext) GetRuleContext() antlr.RuleContext

func (*StatementOptionsContext) IsStatementOptionsContext

func (*StatementOptionsContext) IsStatementOptionsContext()

func (*StatementOptionsContext) LEFT_ROUND_BRACKET

func (s *StatementOptionsContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*StatementOptionsContext) OPTIONS

func (*StatementOptionsContext) RIGHT_ROUND_BRACKET

func (s *StatementOptionsContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*StatementOptionsContext) StatementOption

func (s *StatementOptionsContext) StatementOption(i int) IStatementOptionContext

func (*StatementOptionsContext) ToStringTree

func (s *StatementOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StatementsContext

type StatementsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStatementsContext

func NewEmptyStatementsContext() *StatementsContext

func NewStatementsContext

func NewStatementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementsContext

func (*StatementsContext) Accept

func (s *StatementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StatementsContext) AllSEMI

func (s *StatementsContext) AllSEMI() []antlr.TerminalNode

func (*StatementsContext) AllStatement

func (s *StatementsContext) AllStatement() []IStatementContext

func (*StatementsContext) EnterRule

func (s *StatementsContext) EnterRule(listener antlr.ParseTreeListener)

func (*StatementsContext) ExitRule

func (s *StatementsContext) ExitRule(listener antlr.ParseTreeListener)

func (*StatementsContext) GetParser

func (s *StatementsContext) GetParser() antlr.Parser

func (*StatementsContext) GetRuleContext

func (s *StatementsContext) GetRuleContext() antlr.RuleContext

func (*StatementsContext) IsStatementsContext

func (*StatementsContext) IsStatementsContext()

func (*StatementsContext) SEMI

func (*StatementsContext) Statement

func (s *StatementsContext) Statement(i int) IStatementContext

func (*StatementsContext) ToStringTree

func (s *StatementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StoredQueryDefinitionContext

type StoredQueryDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStoredQueryDefinitionContext

func NewEmptyStoredQueryDefinitionContext() *StoredQueryDefinitionContext

func NewStoredQueryDefinitionContext

func NewStoredQueryDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StoredQueryDefinitionContext

func (*StoredQueryDefinitionContext) AS

func (*StoredQueryDefinitionContext) Accept

func (s *StoredQueryDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StoredQueryDefinitionContext) DeclareBlock

func (*StoredQueryDefinitionContext) EnterRule

func (s *StoredQueryDefinitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*StoredQueryDefinitionContext) ExitRule

func (*StoredQueryDefinitionContext) GetParser

func (s *StoredQueryDefinitionContext) GetParser() antlr.Parser

func (*StoredQueryDefinitionContext) GetQueryName

func (s *StoredQueryDefinitionContext) GetQueryName() IUidContext

func (*StoredQueryDefinitionContext) GetRuleContext

func (s *StoredQueryDefinitionContext) GetRuleContext() antlr.RuleContext

func (*StoredQueryDefinitionContext) GetStoredQuery

func (s *StoredQueryDefinitionContext) GetStoredQuery() IQueryContext

func (*StoredQueryDefinitionContext) IsStoredQueryDefinitionContext

func (*StoredQueryDefinitionContext) IsStoredQueryDefinitionContext()

func (*StoredQueryDefinitionContext) QUERY

func (*StoredQueryDefinitionContext) Query

func (*StoredQueryDefinitionContext) STORED

func (*StoredQueryDefinitionContext) SetQueryName

func (s *StoredQueryDefinitionContext) SetQueryName(v IUidContext)

func (*StoredQueryDefinitionContext) SetStoredQuery

func (s *StoredQueryDefinitionContext) SetStoredQuery(v IQueryContext)

func (*StoredQueryDefinitionContext) ToStringTree

func (s *StoredQueryDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*StoredQueryDefinitionContext) Uid

type StraightJoinContext

type StraightJoinContext struct {
	JoinPartContext
}

func NewStraightJoinContext

func NewStraightJoinContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StraightJoinContext

func (*StraightJoinContext) Accept

func (s *StraightJoinContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StraightJoinContext) EnterRule

func (s *StraightJoinContext) EnterRule(listener antlr.ParseTreeListener)

func (*StraightJoinContext) ExitRule

func (s *StraightJoinContext) ExitRule(listener antlr.ParseTreeListener)

func (*StraightJoinContext) Expression

func (s *StraightJoinContext) Expression() IExpressionContext

func (*StraightJoinContext) GetRuleContext

func (s *StraightJoinContext) GetRuleContext() antlr.RuleContext

func (*StraightJoinContext) ON

func (*StraightJoinContext) STRAIGHT_JOIN

func (s *StraightJoinContext) STRAIGHT_JOIN() antlr.TerminalNode

func (*StraightJoinContext) TableSourceItem

func (s *StraightJoinContext) TableSourceItem() ITableSourceItemContext

type StringConstantContext

type StringConstantContext struct {
	ConstantContext
}

func NewStringConstantContext

func NewStringConstantContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringConstantContext

func (*StringConstantContext) Accept

func (s *StringConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StringConstantContext) EnterRule

func (s *StringConstantContext) EnterRule(listener antlr.ParseTreeListener)

func (*StringConstantContext) ExitRule

func (s *StringConstantContext) ExitRule(listener antlr.ParseTreeListener)

func (*StringConstantContext) GetRuleContext

func (s *StringConstantContext) GetRuleContext() antlr.RuleContext

func (*StringConstantContext) StringLiteral

func (s *StringConstantContext) StringLiteral() IStringLiteralContext

type StringDataTypeContext

type StringDataTypeContext struct {
	DataTypeContext
	// contains filtered or unexported fields
}

func NewStringDataTypeContext

func NewStringDataTypeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *StringDataTypeContext

func (*StringDataTypeContext) Accept

func (s *StringDataTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StringDataTypeContext) AllBINARY

func (s *StringDataTypeContext) AllBINARY() []antlr.TerminalNode

func (*StringDataTypeContext) BINARY

func (*StringDataTypeContext) CHAR

func (*StringDataTypeContext) CHARACTER

func (s *StringDataTypeContext) CHARACTER() antlr.TerminalNode

func (*StringDataTypeContext) COLLATE

func (*StringDataTypeContext) CharSet

func (*StringDataTypeContext) CharsetName

func (s *StringDataTypeContext) CharsetName() ICharsetNameContext

func (*StringDataTypeContext) CollationName

func (s *StringDataTypeContext) CollationName() ICollationNameContext

func (*StringDataTypeContext) EnterRule

func (s *StringDataTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*StringDataTypeContext) ExitRule

func (s *StringDataTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*StringDataTypeContext) GetRuleContext

func (s *StringDataTypeContext) GetRuleContext() antlr.RuleContext

func (*StringDataTypeContext) GetTypeName

func (s *StringDataTypeContext) GetTypeName() antlr.Token

func (*StringDataTypeContext) LONG

func (*StringDataTypeContext) LONGTEXT

func (*StringDataTypeContext) LengthOneDimension

func (s *StringDataTypeContext) LengthOneDimension() ILengthOneDimensionContext

func (*StringDataTypeContext) MEDIUMTEXT

func (s *StringDataTypeContext) MEDIUMTEXT() antlr.TerminalNode

func (*StringDataTypeContext) NCHAR

func (*StringDataTypeContext) NVARCHAR

func (*StringDataTypeContext) SetTypeName

func (s *StringDataTypeContext) SetTypeName(v antlr.Token)

func (*StringDataTypeContext) TEXT

func (*StringDataTypeContext) TINYTEXT

func (*StringDataTypeContext) VARCHAR

func (*StringDataTypeContext) VARYING

type StringLiteralContext

type StringLiteralContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStringLiteralContext

func NewEmptyStringLiteralContext() *StringLiteralContext

func NewStringLiteralContext

func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext

func (*StringLiteralContext) Accept

func (s *StringLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StringLiteralContext) AllSTRING_LITERAL

func (s *StringLiteralContext) AllSTRING_LITERAL() []antlr.TerminalNode

func (*StringLiteralContext) COLLATE

func (*StringLiteralContext) CollationName

func (s *StringLiteralContext) CollationName() ICollationNameContext

func (*StringLiteralContext) EnterRule

func (s *StringLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*StringLiteralContext) ExitRule

func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*StringLiteralContext) GetParser

func (s *StringLiteralContext) GetParser() antlr.Parser

func (*StringLiteralContext) GetRuleContext

func (s *StringLiteralContext) GetRuleContext() antlr.RuleContext

func (*StringLiteralContext) IsStringLiteralContext

func (*StringLiteralContext) IsStringLiteralContext()

func (*StringLiteralContext) START_NATIONAL_STRING_LITERAL

func (s *StringLiteralContext) START_NATIONAL_STRING_LITERAL() antlr.TerminalNode

func (*StringLiteralContext) STRING_CHARSET_NAME

func (s *StringLiteralContext) STRING_CHARSET_NAME() antlr.TerminalNode

func (*StringLiteralContext) STRING_LITERAL

func (s *StringLiteralContext) STRING_LITERAL(i int) antlr.TerminalNode

func (*StringLiteralContext) ToStringTree

func (s *StringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StructDefinitionContext

type StructDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStructDefinitionContext

func NewEmptyStructDefinitionContext() *StructDefinitionContext

func NewStructDefinitionContext

func NewStructDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StructDefinitionContext

func (*StructDefinitionContext) AS

func (*StructDefinitionContext) Accept

func (s *StructDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StructDefinitionContext) AllCOMMA

func (s *StructDefinitionContext) AllCOMMA() []antlr.TerminalNode

func (*StructDefinitionContext) AllColumnDefinition

func (s *StructDefinitionContext) AllColumnDefinition() []IColumnDefinitionContext

func (*StructDefinitionContext) COMMA

func (*StructDefinitionContext) ColumnDefinition

func (s *StructDefinitionContext) ColumnDefinition(i int) IColumnDefinitionContext

func (*StructDefinitionContext) EnterRule

func (s *StructDefinitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*StructDefinitionContext) ExitRule

func (s *StructDefinitionContext) ExitRule(listener antlr.ParseTreeListener)

func (*StructDefinitionContext) GetParser

func (s *StructDefinitionContext) GetParser() antlr.Parser

func (*StructDefinitionContext) GetRuleContext

func (s *StructDefinitionContext) GetRuleContext() antlr.RuleContext

func (*StructDefinitionContext) IsStructDefinitionContext

func (*StructDefinitionContext) IsStructDefinitionContext()

func (*StructDefinitionContext) LEFT_ROUND_BRACKET

func (s *StructDefinitionContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*StructDefinitionContext) RIGHT_ROUND_BRACKET

func (s *StructDefinitionContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*StructDefinitionContext) STRUCT

func (*StructDefinitionContext) TYPE

func (*StructDefinitionContext) ToStringTree

func (s *StructDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*StructDefinitionContext) Uid

type SubqueryExpressionAtomContext

type SubqueryExpressionAtomContext struct {
	ExpressionAtomContext
}

func NewSubqueryExpressionAtomContext

func NewSubqueryExpressionAtomContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubqueryExpressionAtomContext

func (*SubqueryExpressionAtomContext) Accept

func (s *SubqueryExpressionAtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SubqueryExpressionAtomContext) EnterRule

func (s *SubqueryExpressionAtomContext) EnterRule(listener antlr.ParseTreeListener)

func (*SubqueryExpressionAtomContext) ExitRule

func (*SubqueryExpressionAtomContext) GetRuleContext

func (s *SubqueryExpressionAtomContext) GetRuleContext() antlr.RuleContext

func (*SubqueryExpressionAtomContext) LEFT_ROUND_BRACKET

func (s *SubqueryExpressionAtomContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*SubqueryExpressionAtomContext) Query

func (*SubqueryExpressionAtomContext) RIGHT_ROUND_BRACKET

func (s *SubqueryExpressionAtomContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

type SubqueryTableItemContext

type SubqueryTableItemContext struct {
	TableSourceItemContext
	// contains filtered or unexported fields
}

func NewSubqueryTableItemContext

func NewSubqueryTableItemContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubqueryTableItemContext

func (*SubqueryTableItemContext) AS

func (*SubqueryTableItemContext) Accept

func (s *SubqueryTableItemContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SubqueryTableItemContext) EnterRule

func (s *SubqueryTableItemContext) EnterRule(listener antlr.ParseTreeListener)

func (*SubqueryTableItemContext) ExitRule

func (s *SubqueryTableItemContext) ExitRule(listener antlr.ParseTreeListener)

func (*SubqueryTableItemContext) GetAlias

func (s *SubqueryTableItemContext) GetAlias() IUidContext

func (*SubqueryTableItemContext) GetRuleContext

func (s *SubqueryTableItemContext) GetRuleContext() antlr.RuleContext

func (*SubqueryTableItemContext) LEFT_ROUND_BRACKET

func (s *SubqueryTableItemContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*SubqueryTableItemContext) Query

func (*SubqueryTableItemContext) RIGHT_ROUND_BRACKET

func (s *SubqueryTableItemContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*SubqueryTableItemContext) SetAlias

func (s *SubqueryTableItemContext) SetAlias(v IUidContext)

func (*SubqueryTableItemContext) Uid

type SubscriptExpressionContext

type SubscriptExpressionContext struct {
	ExpressionAtomContext
	// contains filtered or unexported fields
}

func NewSubscriptExpressionContext

func NewSubscriptExpressionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubscriptExpressionContext

func (*SubscriptExpressionContext) Accept

func (s *SubscriptExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SubscriptExpressionContext) AllExpressionAtom

func (s *SubscriptExpressionContext) AllExpressionAtom() []IExpressionAtomContext

func (*SubscriptExpressionContext) EnterRule

func (s *SubscriptExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*SubscriptExpressionContext) ExitRule

func (s *SubscriptExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*SubscriptExpressionContext) ExpressionAtom

func (*SubscriptExpressionContext) GetBase

func (*SubscriptExpressionContext) GetIndex

func (*SubscriptExpressionContext) GetRuleContext

func (s *SubscriptExpressionContext) GetRuleContext() antlr.RuleContext

func (*SubscriptExpressionContext) LEFT_SQUARE_BRACKET

func (s *SubscriptExpressionContext) LEFT_SQUARE_BRACKET() antlr.TerminalNode

func (*SubscriptExpressionContext) RIGHT_SQUARE_BRACKET

func (s *SubscriptExpressionContext) RIGHT_SQUARE_BRACKET() antlr.TerminalNode

func (*SubscriptExpressionContext) SetBase

func (*SubscriptExpressionContext) SetIndex

type SubstrFunctionCallContext

type SubstrFunctionCallContext struct {
	SpecificFunctionContext
	// contains filtered or unexported fields
}

func NewSubstrFunctionCallContext

func NewSubstrFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SubstrFunctionCallContext

func (*SubstrFunctionCallContext) Accept

func (s *SubstrFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SubstrFunctionCallContext) AllDecimalLiteral

func (s *SubstrFunctionCallContext) AllDecimalLiteral() []IDecimalLiteralContext

func (*SubstrFunctionCallContext) AllExpression

func (s *SubstrFunctionCallContext) AllExpression() []IExpressionContext

func (*SubstrFunctionCallContext) DecimalLiteral

func (*SubstrFunctionCallContext) EnterRule

func (s *SubstrFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*SubstrFunctionCallContext) ExitRule

func (s *SubstrFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*SubstrFunctionCallContext) Expression

func (*SubstrFunctionCallContext) FOR

func (*SubstrFunctionCallContext) FROM

func (*SubstrFunctionCallContext) GetForDecimal

func (*SubstrFunctionCallContext) GetForExpression

func (s *SubstrFunctionCallContext) GetForExpression() IExpressionContext

func (*SubstrFunctionCallContext) GetFromDecimal

func (*SubstrFunctionCallContext) GetFromExpression

func (s *SubstrFunctionCallContext) GetFromExpression() IExpressionContext

func (*SubstrFunctionCallContext) GetRuleContext

func (s *SubstrFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*SubstrFunctionCallContext) GetSourceExpression

func (s *SubstrFunctionCallContext) GetSourceExpression() IExpressionContext

func (*SubstrFunctionCallContext) GetSourceString

func (s *SubstrFunctionCallContext) GetSourceString() IStringLiteralContext

func (*SubstrFunctionCallContext) LEFT_ROUND_BRACKET

func (s *SubstrFunctionCallContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*SubstrFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *SubstrFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*SubstrFunctionCallContext) SUBSTR

func (*SubstrFunctionCallContext) SUBSTRING

func (*SubstrFunctionCallContext) SetForDecimal

func (*SubstrFunctionCallContext) SetForExpression

func (s *SubstrFunctionCallContext) SetForExpression(v IExpressionContext)

func (*SubstrFunctionCallContext) SetFromDecimal

func (*SubstrFunctionCallContext) SetFromExpression

func (s *SubstrFunctionCallContext) SetFromExpression(v IExpressionContext)

func (*SubstrFunctionCallContext) SetSourceExpression

func (s *SubstrFunctionCallContext) SetSourceExpression(v IExpressionContext)

func (*SubstrFunctionCallContext) SetSourceString

func (s *SubstrFunctionCallContext) SetSourceString(v IStringLiteralContext)

func (*SubstrFunctionCallContext) StringLiteral

type TableDefinitionContext

type TableDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableDefinitionContext

func NewEmptyTableDefinitionContext() *TableDefinitionContext

func NewTableDefinitionContext

func NewTableDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableDefinitionContext

func (*TableDefinitionContext) Accept

func (s *TableDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TableDefinitionContext) AllCOMMA

func (s *TableDefinitionContext) AllCOMMA() []antlr.TerminalNode

func (*TableDefinitionContext) AllColumnDefinition

func (s *TableDefinitionContext) AllColumnDefinition() []IColumnDefinitionContext

func (*TableDefinitionContext) COMMA

func (*TableDefinitionContext) ColumnDefinition

func (s *TableDefinitionContext) ColumnDefinition(i int) IColumnDefinitionContext

func (*TableDefinitionContext) EnterRule

func (s *TableDefinitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*TableDefinitionContext) ExitRule

func (s *TableDefinitionContext) ExitRule(listener antlr.ParseTreeListener)

func (*TableDefinitionContext) GetParser

func (s *TableDefinitionContext) GetParser() antlr.Parser

func (*TableDefinitionContext) GetRuleContext

func (s *TableDefinitionContext) GetRuleContext() antlr.RuleContext

func (*TableDefinitionContext) IsTableDefinitionContext

func (*TableDefinitionContext) IsTableDefinitionContext()

func (*TableDefinitionContext) LEFT_ROUND_BRACKET

func (s *TableDefinitionContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*TableDefinitionContext) PrimaryKeyDefinition

func (s *TableDefinitionContext) PrimaryKeyDefinition() IPrimaryKeyDefinitionContext

func (*TableDefinitionContext) RIGHT_ROUND_BRACKET

func (s *TableDefinitionContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*TableDefinitionContext) TABLE

func (*TableDefinitionContext) ToStringTree

func (s *TableDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*TableDefinitionContext) Uid

type TableFunctionColumnListContext

type TableFunctionColumnListContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableFunctionColumnListContext

func NewEmptyTableFunctionColumnListContext() *TableFunctionColumnListContext

func NewTableFunctionColumnListContext

func NewTableFunctionColumnListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableFunctionColumnListContext

func (*TableFunctionColumnListContext) Accept

func (s *TableFunctionColumnListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TableFunctionColumnListContext) AllTableFunctionColumnListElement

func (s *TableFunctionColumnListContext) AllTableFunctionColumnListElement() []ITableFunctionColumnListElementContext

func (*TableFunctionColumnListContext) EnterRule

func (*TableFunctionColumnListContext) ExitRule

func (*TableFunctionColumnListContext) GetParser

func (*TableFunctionColumnListContext) GetRuleContext

func (s *TableFunctionColumnListContext) GetRuleContext() antlr.RuleContext

func (*TableFunctionColumnListContext) IsTableFunctionColumnListContext

func (*TableFunctionColumnListContext) IsTableFunctionColumnListContext()

func (*TableFunctionColumnListContext) LEFT_ROUND_BRACKET

func (s *TableFunctionColumnListContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*TableFunctionColumnListContext) RIGHT_ROUND_BRACKET

func (s *TableFunctionColumnListContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*TableFunctionColumnListContext) TableFunctionColumnListElement

func (s *TableFunctionColumnListContext) TableFunctionColumnListElement(i int) ITableFunctionColumnListElementContext

func (*TableFunctionColumnListContext) ToStringTree

func (s *TableFunctionColumnListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TableFunctionColumnListElementContext

type TableFunctionColumnListElementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableFunctionColumnListElementContext

func NewEmptyTableFunctionColumnListElementContext() *TableFunctionColumnListElementContext

func NewTableFunctionColumnListElementContext

func NewTableFunctionColumnListElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableFunctionColumnListElementContext

func (*TableFunctionColumnListElementContext) Accept

func (s *TableFunctionColumnListElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TableFunctionColumnListElementContext) ColumnType

func (*TableFunctionColumnListElementContext) EnterRule

func (*TableFunctionColumnListElementContext) ExitRule

func (*TableFunctionColumnListElementContext) GetColumnDataType

func (*TableFunctionColumnListElementContext) GetColumnName

func (*TableFunctionColumnListElementContext) GetParser

func (*TableFunctionColumnListElementContext) GetRuleContext

func (*TableFunctionColumnListElementContext) IsTableFunctionColumnListElementContext

func (*TableFunctionColumnListElementContext) IsTableFunctionColumnListElementContext()

func (*TableFunctionColumnListElementContext) SetColumnDataType

func (*TableFunctionColumnListElementContext) SetColumnName

func (*TableFunctionColumnListElementContext) ToStringTree

func (s *TableFunctionColumnListElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*TableFunctionColumnListElementContext) Uid

type TableFunctionContext

type TableFunctionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableFunctionContext

func NewEmptyTableFunctionContext() *TableFunctionContext

func NewTableFunctionContext

func NewTableFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableFunctionContext

func (*TableFunctionContext) Accept

func (s *TableFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TableFunctionContext) EnterRule

func (s *TableFunctionContext) EnterRule(listener antlr.ParseTreeListener)

func (*TableFunctionContext) ExitRule

func (s *TableFunctionContext) ExitRule(listener antlr.ParseTreeListener)

func (*TableFunctionContext) GetParser

func (s *TableFunctionContext) GetParser() antlr.Parser

func (*TableFunctionContext) GetRuleContext

func (s *TableFunctionContext) GetRuleContext() antlr.RuleContext

func (*TableFunctionContext) InlineTableDefinition

func (s *TableFunctionContext) InlineTableDefinition() IInlineTableDefinitionContext

func (*TableFunctionContext) IsTableFunctionContext

func (*TableFunctionContext) IsTableFunctionContext()

func (*TableFunctionContext) LEFT_ROUND_BRACKET

func (s *TableFunctionContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*TableFunctionContext) NamedOrUnnamedFunctionArgs

func (s *TableFunctionContext) NamedOrUnnamedFunctionArgs() INamedOrUnnamedFunctionArgsContext

func (*TableFunctionContext) RIGHT_ROUND_BRACKET

func (s *TableFunctionContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*TableFunctionContext) TableFunctionName

func (s *TableFunctionContext) TableFunctionName() ITableFunctionNameContext

func (*TableFunctionContext) ToStringTree

func (s *TableFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TableFunctionNameContext

type TableFunctionNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableFunctionNameContext

func NewEmptyTableFunctionNameContext() *TableFunctionNameContext

func NewTableFunctionNameContext

func NewTableFunctionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableFunctionNameContext

func (*TableFunctionNameContext) Accept

func (s *TableFunctionNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TableFunctionNameContext) EnterRule

func (s *TableFunctionNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*TableFunctionNameContext) ExitRule

func (s *TableFunctionNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*TableFunctionNameContext) FullId

func (*TableFunctionNameContext) GetParser

func (s *TableFunctionNameContext) GetParser() antlr.Parser

func (*TableFunctionNameContext) GetRuleContext

func (s *TableFunctionNameContext) GetRuleContext() antlr.RuleContext

func (*TableFunctionNameContext) IsTableFunctionNameContext

func (*TableFunctionNameContext) IsTableFunctionNameContext()

func (*TableFunctionNameContext) ToStringTree

func (s *TableFunctionNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TableIndexesContext

type TableIndexesContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableIndexesContext

func NewEmptyTableIndexesContext() *TableIndexesContext

func NewTableIndexesContext

func NewTableIndexesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableIndexesContext

func (*TableIndexesContext) Accept

func (s *TableIndexesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TableIndexesContext) EnterRule

func (s *TableIndexesContext) EnterRule(listener antlr.ParseTreeListener)

func (*TableIndexesContext) ExitRule

func (s *TableIndexesContext) ExitRule(listener antlr.ParseTreeListener)

func (*TableIndexesContext) GetIndexFormat

func (s *TableIndexesContext) GetIndexFormat() antlr.Token

func (*TableIndexesContext) GetParser

func (s *TableIndexesContext) GetParser() antlr.Parser

func (*TableIndexesContext) GetRuleContext

func (s *TableIndexesContext) GetRuleContext() antlr.RuleContext

func (*TableIndexesContext) INDEX

func (*TableIndexesContext) IsTableIndexesContext

func (*TableIndexesContext) IsTableIndexesContext()

func (*TableIndexesContext) KEY

func (*TableIndexesContext) LEFT_ROUND_BRACKET

func (s *TableIndexesContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*TableIndexesContext) RIGHT_ROUND_BRACKET

func (s *TableIndexesContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*TableIndexesContext) SetIndexFormat

func (s *TableIndexesContext) SetIndexFormat(v antlr.Token)

func (*TableIndexesContext) TableName

func (s *TableIndexesContext) TableName() ITableNameContext

func (*TableIndexesContext) ToStringTree

func (s *TableIndexesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*TableIndexesContext) UidList

func (s *TableIndexesContext) UidList() IUidListContext

type TableNameContext

type TableNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableNameContext

func NewEmptyTableNameContext() *TableNameContext

func NewTableNameContext

func NewTableNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableNameContext

func (*TableNameContext) Accept

func (s *TableNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TableNameContext) EnterRule

func (s *TableNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*TableNameContext) ExitRule

func (s *TableNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*TableNameContext) FullId

func (s *TableNameContext) FullId() IFullIdContext

func (*TableNameContext) GetParser

func (s *TableNameContext) GetParser() antlr.Parser

func (*TableNameContext) GetRuleContext

func (s *TableNameContext) GetRuleContext() antlr.RuleContext

func (*TableNameContext) IsTableNameContext

func (*TableNameContext) IsTableNameContext()

func (*TableNameContext) ToStringTree

func (s *TableNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TableSourceBaseContext

type TableSourceBaseContext struct {
	TableSourceContext
}

func NewTableSourceBaseContext

func NewTableSourceBaseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableSourceBaseContext

func (*TableSourceBaseContext) Accept

func (s *TableSourceBaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TableSourceBaseContext) AllJoinPart

func (s *TableSourceBaseContext) AllJoinPart() []IJoinPartContext

func (*TableSourceBaseContext) EnterRule

func (s *TableSourceBaseContext) EnterRule(listener antlr.ParseTreeListener)

func (*TableSourceBaseContext) ExitRule

func (s *TableSourceBaseContext) ExitRule(listener antlr.ParseTreeListener)

func (*TableSourceBaseContext) GetRuleContext

func (s *TableSourceBaseContext) GetRuleContext() antlr.RuleContext

func (*TableSourceBaseContext) JoinPart

func (*TableSourceBaseContext) TableSourceItem

func (s *TableSourceBaseContext) TableSourceItem() ITableSourceItemContext

type TableSourceContext

type TableSourceContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableSourceContext

func NewEmptyTableSourceContext() *TableSourceContext

func NewTableSourceContext

func NewTableSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableSourceContext

func (*TableSourceContext) CopyAll

func (s *TableSourceContext) CopyAll(ctx *TableSourceContext)

func (*TableSourceContext) GetParser

func (s *TableSourceContext) GetParser() antlr.Parser

func (*TableSourceContext) GetRuleContext

func (s *TableSourceContext) GetRuleContext() antlr.RuleContext

func (*TableSourceContext) IsTableSourceContext

func (*TableSourceContext) IsTableSourceContext()

func (*TableSourceContext) ToStringTree

func (s *TableSourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TableSourceItemContext

type TableSourceItemContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableSourceItemContext

func NewEmptyTableSourceItemContext() *TableSourceItemContext

func NewTableSourceItemContext

func NewTableSourceItemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableSourceItemContext

func (*TableSourceItemContext) CopyAll

func (*TableSourceItemContext) GetParser

func (s *TableSourceItemContext) GetParser() antlr.Parser

func (*TableSourceItemContext) GetRuleContext

func (s *TableSourceItemContext) GetRuleContext() antlr.RuleContext

func (*TableSourceItemContext) IsTableSourceItemContext

func (*TableSourceItemContext) IsTableSourceItemContext()

func (*TableSourceItemContext) ToStringTree

func (s *TableSourceItemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TableSourcesContext

type TableSourcesContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTableSourcesContext

func NewEmptyTableSourcesContext() *TableSourcesContext

func NewTableSourcesContext

func NewTableSourcesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableSourcesContext

func (*TableSourcesContext) Accept

func (s *TableSourcesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TableSourcesContext) AllCOMMA

func (s *TableSourcesContext) AllCOMMA() []antlr.TerminalNode

func (*TableSourcesContext) AllTableSource

func (s *TableSourcesContext) AllTableSource() []ITableSourceContext

func (*TableSourcesContext) COMMA

func (*TableSourcesContext) EnterRule

func (s *TableSourcesContext) EnterRule(listener antlr.ParseTreeListener)

func (*TableSourcesContext) ExitRule

func (s *TableSourcesContext) ExitRule(listener antlr.ParseTreeListener)

func (*TableSourcesContext) GetParser

func (s *TableSourcesContext) GetParser() antlr.Parser

func (*TableSourcesContext) GetRuleContext

func (s *TableSourcesContext) GetRuleContext() antlr.RuleContext

func (*TableSourcesContext) IsTableSourcesContext

func (*TableSourcesContext) IsTableSourcesContext()

func (*TableSourcesContext) TableSource

func (s *TableSourcesContext) TableSource(i int) ITableSourceContext

func (*TableSourcesContext) ToStringTree

func (s *TableSourcesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TableValuedFunctionContext

type TableValuedFunctionContext struct {
	TableSourceItemContext
	// contains filtered or unexported fields
}

func NewTableValuedFunctionContext

func NewTableValuedFunctionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TableValuedFunctionContext

func (*TableValuedFunctionContext) AS

func (*TableValuedFunctionContext) Accept

func (s *TableValuedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TableValuedFunctionContext) EnterRule

func (s *TableValuedFunctionContext) EnterRule(listener antlr.ParseTreeListener)

func (*TableValuedFunctionContext) ExitRule

func (s *TableValuedFunctionContext) ExitRule(listener antlr.ParseTreeListener)

func (*TableValuedFunctionContext) GetAlias

func (*TableValuedFunctionContext) GetRuleContext

func (s *TableValuedFunctionContext) GetRuleContext() antlr.RuleContext

func (*TableValuedFunctionContext) SetAlias

func (s *TableValuedFunctionContext) SetAlias(v IUidContext)

func (*TableValuedFunctionContext) TableFunction

func (*TableValuedFunctionContext) Uid

type TablesContext

type TablesContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTablesContext

func NewEmptyTablesContext() *TablesContext

func NewTablesContext

func NewTablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablesContext

func (*TablesContext) Accept

func (s *TablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TablesContext) AllCOMMA

func (s *TablesContext) AllCOMMA() []antlr.TerminalNode

func (*TablesContext) AllTableName

func (s *TablesContext) AllTableName() []ITableNameContext

func (*TablesContext) COMMA

func (s *TablesContext) COMMA(i int) antlr.TerminalNode

func (*TablesContext) EnterRule

func (s *TablesContext) EnterRule(listener antlr.ParseTreeListener)

func (*TablesContext) ExitRule

func (s *TablesContext) ExitRule(listener antlr.ParseTreeListener)

func (*TablesContext) GetParser

func (s *TablesContext) GetParser() antlr.Parser

func (*TablesContext) GetRuleContext

func (s *TablesContext) GetRuleContext() antlr.RuleContext

func (*TablesContext) IsTablesContext

func (*TablesContext) IsTablesContext()

func (*TablesContext) TableName

func (s *TablesContext) TableName(i int) ITableNameContext

func (*TablesContext) ToStringTree

func (s *TablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TempSqlInvokedFunctionContext

type TempSqlInvokedFunctionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTempSqlInvokedFunctionContext

func NewEmptyTempSqlInvokedFunctionContext() *TempSqlInvokedFunctionContext

func NewTempSqlInvokedFunctionContext

func NewTempSqlInvokedFunctionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TempSqlInvokedFunctionContext

func (*TempSqlInvokedFunctionContext) Accept

func (s *TempSqlInvokedFunctionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TempSqlInvokedFunctionContext) COMMIT

func (*TempSqlInvokedFunctionContext) DROP

func (*TempSqlInvokedFunctionContext) EnterRule

func (s *TempSqlInvokedFunctionContext) EnterRule(listener antlr.ParseTreeListener)

func (*TempSqlInvokedFunctionContext) ExitRule

func (*TempSqlInvokedFunctionContext) FUNCTION

func (*TempSqlInvokedFunctionContext) FunctionSpecification

func (*TempSqlInvokedFunctionContext) GetParser

func (*TempSqlInvokedFunctionContext) GetRuleContext

func (s *TempSqlInvokedFunctionContext) GetRuleContext() antlr.RuleContext

func (*TempSqlInvokedFunctionContext) IsTempSqlInvokedFunctionContext

func (*TempSqlInvokedFunctionContext) IsTempSqlInvokedFunctionContext()

func (*TempSqlInvokedFunctionContext) ON

func (*TempSqlInvokedFunctionContext) RoutineBody

func (*TempSqlInvokedFunctionContext) ToStringTree

func (s *TempSqlInvokedFunctionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TemplateClauseContext

type TemplateClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTemplateClauseContext

func NewEmptyTemplateClauseContext() *TemplateClauseContext

func NewTemplateClauseContext

func NewTemplateClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TemplateClauseContext

func (*TemplateClauseContext) Accept

func (s *TemplateClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TemplateClauseContext) CREATE

func (*TemplateClauseContext) EnterRule

func (s *TemplateClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*TemplateClauseContext) EnumDefinition

func (s *TemplateClauseContext) EnumDefinition() IEnumDefinitionContext

func (*TemplateClauseContext) ExitRule

func (s *TemplateClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*TemplateClauseContext) GetParser

func (s *TemplateClauseContext) GetParser() antlr.Parser

func (*TemplateClauseContext) GetRuleContext

func (s *TemplateClauseContext) GetRuleContext() antlr.RuleContext

func (*TemplateClauseContext) IndexDefinition

func (s *TemplateClauseContext) IndexDefinition() IIndexDefinitionContext

func (*TemplateClauseContext) IsTemplateClauseContext

func (*TemplateClauseContext) IsTemplateClauseContext()

func (*TemplateClauseContext) SqlInvokedFunction

func (s *TemplateClauseContext) SqlInvokedFunction() ISqlInvokedFunctionContext

func (*TemplateClauseContext) StoredQueryDefinition

func (s *TemplateClauseContext) StoredQueryDefinition() IStoredQueryDefinitionContext

func (*TemplateClauseContext) StructDefinition

func (s *TemplateClauseContext) StructDefinition() IStructDefinitionContext

func (*TemplateClauseContext) TableDefinition

func (s *TemplateClauseContext) TableDefinition() ITableDefinitionContext

func (*TemplateClauseContext) ToStringTree

func (s *TemplateClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*TemplateClauseContext) ViewDefinition

func (s *TemplateClauseContext) ViewDefinition() IViewDefinitionContext

type TransactionLevelContext

type TransactionLevelContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTransactionLevelContext

func NewEmptyTransactionLevelContext() *TransactionLevelContext

func NewTransactionLevelContext

func NewTransactionLevelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionLevelContext

func (*TransactionLevelContext) Accept

func (s *TransactionLevelContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TransactionLevelContext) COMMITTED

func (*TransactionLevelContext) EnterRule

func (s *TransactionLevelContext) EnterRule(listener antlr.ParseTreeListener)

func (*TransactionLevelContext) ExitRule

func (s *TransactionLevelContext) ExitRule(listener antlr.ParseTreeListener)

func (*TransactionLevelContext) GetParser

func (s *TransactionLevelContext) GetParser() antlr.Parser

func (*TransactionLevelContext) GetRuleContext

func (s *TransactionLevelContext) GetRuleContext() antlr.RuleContext

func (*TransactionLevelContext) IsTransactionLevelContext

func (*TransactionLevelContext) IsTransactionLevelContext()

func (*TransactionLevelContext) READ

func (*TransactionLevelContext) SERIALIZABLE

func (s *TransactionLevelContext) SERIALIZABLE() antlr.TerminalNode

func (*TransactionLevelContext) ToStringTree

func (s *TransactionLevelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TransactionOptionContext

type TransactionOptionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTransactionOptionContext

func NewEmptyTransactionOptionContext() *TransactionOptionContext

func NewTransactionOptionContext

func NewTransactionOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionOptionContext

func (*TransactionOptionContext) Accept

func (s *TransactionOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TransactionOptionContext) EnterRule

func (s *TransactionOptionContext) EnterRule(listener antlr.ParseTreeListener)

func (*TransactionOptionContext) ExitRule

func (s *TransactionOptionContext) ExitRule(listener antlr.ParseTreeListener)

func (*TransactionOptionContext) GetParser

func (s *TransactionOptionContext) GetParser() antlr.Parser

func (*TransactionOptionContext) GetRuleContext

func (s *TransactionOptionContext) GetRuleContext() antlr.RuleContext

func (*TransactionOptionContext) ISOLATION

func (*TransactionOptionContext) IsTransactionOptionContext

func (*TransactionOptionContext) IsTransactionOptionContext()

func (*TransactionOptionContext) LEVEL

func (*TransactionOptionContext) ToStringTree

func (s *TransactionOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*TransactionOptionContext) TransactionLevel

func (s *TransactionOptionContext) TransactionLevel() ITransactionLevelContext

type TransactionStatementContext

type TransactionStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTransactionStatementContext

func NewEmptyTransactionStatementContext() *TransactionStatementContext

func NewTransactionStatementContext

func NewTransactionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionStatementContext

func (*TransactionStatementContext) Accept

func (s *TransactionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TransactionStatementContext) CommitStatement

func (*TransactionStatementContext) EnterRule

func (s *TransactionStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*TransactionStatementContext) ExitRule

func (s *TransactionStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*TransactionStatementContext) GetParser

func (s *TransactionStatementContext) GetParser() antlr.Parser

func (*TransactionStatementContext) GetRuleContext

func (s *TransactionStatementContext) GetRuleContext() antlr.RuleContext

func (*TransactionStatementContext) IsTransactionStatementContext

func (*TransactionStatementContext) IsTransactionStatementContext()

func (*TransactionStatementContext) RollbackStatement

func (*TransactionStatementContext) StartTransaction

func (*TransactionStatementContext) ToStringTree

func (s *TransactionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TraversalOrderClauseContext

type TraversalOrderClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTraversalOrderClauseContext

func NewEmptyTraversalOrderClauseContext() *TraversalOrderClauseContext

func NewTraversalOrderClauseContext

func NewTraversalOrderClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TraversalOrderClauseContext

func (*TraversalOrderClauseContext) Accept

func (s *TraversalOrderClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TraversalOrderClauseContext) EnterRule

func (s *TraversalOrderClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*TraversalOrderClauseContext) ExitRule

func (s *TraversalOrderClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*TraversalOrderClauseContext) GetOrder

func (s *TraversalOrderClauseContext) GetOrder() antlr.Token

func (*TraversalOrderClauseContext) GetParser

func (s *TraversalOrderClauseContext) GetParser() antlr.Parser

func (*TraversalOrderClauseContext) GetRuleContext

func (s *TraversalOrderClauseContext) GetRuleContext() antlr.RuleContext

func (*TraversalOrderClauseContext) IsTraversalOrderClauseContext

func (*TraversalOrderClauseContext) IsTraversalOrderClauseContext()

func (*TraversalOrderClauseContext) LEVEL_ORDER

func (*TraversalOrderClauseContext) ORDER

func (*TraversalOrderClauseContext) POST_ORDER

func (*TraversalOrderClauseContext) PRE_ORDER

func (*TraversalOrderClauseContext) SetOrder

func (s *TraversalOrderClauseContext) SetOrder(v antlr.Token)

func (*TraversalOrderClauseContext) TRAVERSAL

func (*TraversalOrderClauseContext) ToStringTree

func (s *TraversalOrderClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TrimFunctionCallContext

type TrimFunctionCallContext struct {
	SpecificFunctionContext
	// contains filtered or unexported fields
}

func NewTrimFunctionCallContext

func NewTrimFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *TrimFunctionCallContext

func (*TrimFunctionCallContext) Accept

func (s *TrimFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*TrimFunctionCallContext) AllExpression

func (s *TrimFunctionCallContext) AllExpression() []IExpressionContext

func (*TrimFunctionCallContext) AllStringLiteral

func (s *TrimFunctionCallContext) AllStringLiteral() []IStringLiteralContext

func (*TrimFunctionCallContext) BOTH

func (*TrimFunctionCallContext) EnterRule

func (s *TrimFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*TrimFunctionCallContext) ExitRule

func (s *TrimFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*TrimFunctionCallContext) Expression

func (*TrimFunctionCallContext) FROM

func (*TrimFunctionCallContext) GetFromExpression

func (s *TrimFunctionCallContext) GetFromExpression() IExpressionContext

func (*TrimFunctionCallContext) GetFromString

func (*TrimFunctionCallContext) GetPositioinForm

func (s *TrimFunctionCallContext) GetPositioinForm() antlr.Token

func (*TrimFunctionCallContext) GetRuleContext

func (s *TrimFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*TrimFunctionCallContext) GetSourceExpression

func (s *TrimFunctionCallContext) GetSourceExpression() IExpressionContext

func (*TrimFunctionCallContext) GetSourceString

func (s *TrimFunctionCallContext) GetSourceString() IStringLiteralContext

func (*TrimFunctionCallContext) LEADING

func (*TrimFunctionCallContext) LEFT_ROUND_BRACKET

func (s *TrimFunctionCallContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*TrimFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *TrimFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*TrimFunctionCallContext) SetFromExpression

func (s *TrimFunctionCallContext) SetFromExpression(v IExpressionContext)

func (*TrimFunctionCallContext) SetFromString

func (s *TrimFunctionCallContext) SetFromString(v IStringLiteralContext)

func (*TrimFunctionCallContext) SetPositioinForm

func (s *TrimFunctionCallContext) SetPositioinForm(v antlr.Token)

func (*TrimFunctionCallContext) SetSourceExpression

func (s *TrimFunctionCallContext) SetSourceExpression(v IExpressionContext)

func (*TrimFunctionCallContext) SetSourceString

func (s *TrimFunctionCallContext) SetSourceString(v IStringLiteralContext)

func (*TrimFunctionCallContext) StringLiteral

func (*TrimFunctionCallContext) TRAILING

func (*TrimFunctionCallContext) TRIM

type UidContext

type UidContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUidContext

func NewEmptyUidContext() *UidContext

func NewUidContext

func NewUidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UidContext

func (*UidContext) Accept

func (s *UidContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UidContext) DOUBLE_QUOTE_ID

func (s *UidContext) DOUBLE_QUOTE_ID() antlr.TerminalNode

func (*UidContext) EnterRule

func (s *UidContext) EnterRule(listener antlr.ParseTreeListener)

func (*UidContext) ExitRule

func (s *UidContext) ExitRule(listener antlr.ParseTreeListener)

func (*UidContext) GetParser

func (s *UidContext) GetParser() antlr.Parser

func (*UidContext) GetRuleContext

func (s *UidContext) GetRuleContext() antlr.RuleContext

func (*UidContext) IsUidContext

func (*UidContext) IsUidContext()

func (*UidContext) SimpleId

func (s *UidContext) SimpleId() ISimpleIdContext

func (*UidContext) ToStringTree

func (s *UidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type UidListContext

type UidListContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUidListContext

func NewEmptyUidListContext() *UidListContext

func NewUidListContext

func NewUidListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UidListContext

func (*UidListContext) Accept

func (s *UidListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UidListContext) AllCOMMA

func (s *UidListContext) AllCOMMA() []antlr.TerminalNode

func (*UidListContext) AllUid

func (s *UidListContext) AllUid() []IUidContext

func (*UidListContext) COMMA

func (s *UidListContext) COMMA(i int) antlr.TerminalNode

func (*UidListContext) EnterRule

func (s *UidListContext) EnterRule(listener antlr.ParseTreeListener)

func (*UidListContext) ExitRule

func (s *UidListContext) ExitRule(listener antlr.ParseTreeListener)

func (*UidListContext) GetParser

func (s *UidListContext) GetParser() antlr.Parser

func (*UidListContext) GetRuleContext

func (s *UidListContext) GetRuleContext() antlr.RuleContext

func (*UidListContext) IsUidListContext

func (*UidListContext) IsUidListContext()

func (*UidListContext) ToStringTree

func (s *UidListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*UidListContext) Uid

func (s *UidListContext) Uid(i int) IUidContext

type UidListWithNestingsContext

type UidListWithNestingsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUidListWithNestingsContext

func NewEmptyUidListWithNestingsContext() *UidListWithNestingsContext

func NewUidListWithNestingsContext

func NewUidListWithNestingsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UidListWithNestingsContext

func (*UidListWithNestingsContext) Accept

func (s *UidListWithNestingsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UidListWithNestingsContext) AllCOMMA

func (*UidListWithNestingsContext) AllUidWithNestings

func (s *UidListWithNestingsContext) AllUidWithNestings() []IUidWithNestingsContext

func (*UidListWithNestingsContext) COMMA

func (*UidListWithNestingsContext) EnterRule

func (s *UidListWithNestingsContext) EnterRule(listener antlr.ParseTreeListener)

func (*UidListWithNestingsContext) ExitRule

func (s *UidListWithNestingsContext) ExitRule(listener antlr.ParseTreeListener)

func (*UidListWithNestingsContext) GetParser

func (s *UidListWithNestingsContext) GetParser() antlr.Parser

func (*UidListWithNestingsContext) GetRuleContext

func (s *UidListWithNestingsContext) GetRuleContext() antlr.RuleContext

func (*UidListWithNestingsContext) IsUidListWithNestingsContext

func (*UidListWithNestingsContext) IsUidListWithNestingsContext()

func (*UidListWithNestingsContext) ToStringTree

func (s *UidListWithNestingsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*UidListWithNestingsContext) UidWithNestings

type UidListWithNestingsInParensContext

type UidListWithNestingsInParensContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUidListWithNestingsInParensContext

func NewEmptyUidListWithNestingsInParensContext() *UidListWithNestingsInParensContext

func NewUidListWithNestingsInParensContext

func NewUidListWithNestingsInParensContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UidListWithNestingsInParensContext

func (*UidListWithNestingsInParensContext) Accept

func (s *UidListWithNestingsInParensContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UidListWithNestingsInParensContext) EnterRule

func (*UidListWithNestingsInParensContext) ExitRule

func (*UidListWithNestingsInParensContext) GetParser

func (*UidListWithNestingsInParensContext) GetRuleContext

func (*UidListWithNestingsInParensContext) IsUidListWithNestingsInParensContext

func (*UidListWithNestingsInParensContext) IsUidListWithNestingsInParensContext()

func (*UidListWithNestingsInParensContext) LEFT_ROUND_BRACKET

func (s *UidListWithNestingsInParensContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*UidListWithNestingsInParensContext) RIGHT_ROUND_BRACKET

func (s *UidListWithNestingsInParensContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*UidListWithNestingsInParensContext) ToStringTree

func (s *UidListWithNestingsInParensContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*UidListWithNestingsInParensContext) UidListWithNestings

type UidWithNestingsContext

type UidWithNestingsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUidWithNestingsContext

func NewEmptyUidWithNestingsContext() *UidWithNestingsContext

func NewUidWithNestingsContext

func NewUidWithNestingsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UidWithNestingsContext

func (*UidWithNestingsContext) Accept

func (s *UidWithNestingsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UidWithNestingsContext) EnterRule

func (s *UidWithNestingsContext) EnterRule(listener antlr.ParseTreeListener)

func (*UidWithNestingsContext) ExitRule

func (s *UidWithNestingsContext) ExitRule(listener antlr.ParseTreeListener)

func (*UidWithNestingsContext) GetParser

func (s *UidWithNestingsContext) GetParser() antlr.Parser

func (*UidWithNestingsContext) GetRuleContext

func (s *UidWithNestingsContext) GetRuleContext() antlr.RuleContext

func (*UidWithNestingsContext) IsUidWithNestingsContext

func (*UidWithNestingsContext) IsUidWithNestingsContext()

func (*UidWithNestingsContext) ToStringTree

func (s *UidWithNestingsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*UidWithNestingsContext) Uid

func (*UidWithNestingsContext) UidListWithNestingsInParens

func (s *UidWithNestingsContext) UidListWithNestingsInParens() IUidListWithNestingsInParensContext

type UnaryOperatorContext

type UnaryOperatorContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUnaryOperatorContext

func NewEmptyUnaryOperatorContext() *UnaryOperatorContext

func NewUnaryOperatorContext

func NewUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryOperatorContext

func (*UnaryOperatorContext) Accept

func (s *UnaryOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UnaryOperatorContext) BIT_NOT_OP

func (s *UnaryOperatorContext) BIT_NOT_OP() antlr.TerminalNode

func (*UnaryOperatorContext) EXCLAMATION_SYMBOL

func (s *UnaryOperatorContext) EXCLAMATION_SYMBOL() antlr.TerminalNode

func (*UnaryOperatorContext) EnterRule

func (s *UnaryOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*UnaryOperatorContext) ExitRule

func (s *UnaryOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*UnaryOperatorContext) GetParser

func (s *UnaryOperatorContext) GetParser() antlr.Parser

func (*UnaryOperatorContext) GetRuleContext

func (s *UnaryOperatorContext) GetRuleContext() antlr.RuleContext

func (*UnaryOperatorContext) IsUnaryOperatorContext

func (*UnaryOperatorContext) IsUnaryOperatorContext()

func (*UnaryOperatorContext) MINUS

func (*UnaryOperatorContext) NOT

func (*UnaryOperatorContext) PLUS

func (*UnaryOperatorContext) ToStringTree

func (s *UnaryOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type UpdateStatementContext

type UpdateStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUpdateStatementContext

func NewEmptyUpdateStatementContext() *UpdateStatementContext

func NewUpdateStatementContext

func NewUpdateStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdateStatementContext

func (*UpdateStatementContext) AS

func (*UpdateStatementContext) Accept

func (s *UpdateStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UpdateStatementContext) AllCOMMA

func (s *UpdateStatementContext) AllCOMMA() []antlr.TerminalNode

func (*UpdateStatementContext) AllUpdatedElement

func (s *UpdateStatementContext) AllUpdatedElement() []IUpdatedElementContext

func (*UpdateStatementContext) COMMA

func (*UpdateStatementContext) EnterRule

func (s *UpdateStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*UpdateStatementContext) ExitRule

func (s *UpdateStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*UpdateStatementContext) GetParser

func (s *UpdateStatementContext) GetParser() antlr.Parser

func (*UpdateStatementContext) GetRuleContext

func (s *UpdateStatementContext) GetRuleContext() antlr.RuleContext

func (*UpdateStatementContext) IsUpdateStatementContext

func (*UpdateStatementContext) IsUpdateStatementContext()

func (*UpdateStatementContext) RETURNING

func (s *UpdateStatementContext) RETURNING() antlr.TerminalNode

func (*UpdateStatementContext) SET

func (*UpdateStatementContext) SelectElements

func (s *UpdateStatementContext) SelectElements() ISelectElementsContext

func (*UpdateStatementContext) StatementOptions

func (s *UpdateStatementContext) StatementOptions() IStatementOptionsContext

func (*UpdateStatementContext) TableName

func (*UpdateStatementContext) ToStringTree

func (s *UpdateStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*UpdateStatementContext) UPDATE

func (*UpdateStatementContext) Uid

func (*UpdateStatementContext) UpdatedElement

func (s *UpdateStatementContext) UpdatedElement(i int) IUpdatedElementContext

func (*UpdateStatementContext) WHERE

func (*UpdateStatementContext) WhereExpr

type UpdatedElementContext

type UpdatedElementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUpdatedElementContext

func NewEmptyUpdatedElementContext() *UpdatedElementContext

func NewUpdatedElementContext

func NewUpdatedElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdatedElementContext

func (*UpdatedElementContext) Accept

func (s *UpdatedElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UpdatedElementContext) DEFAULT

func (*UpdatedElementContext) EQUAL_SYMBOL

func (s *UpdatedElementContext) EQUAL_SYMBOL() antlr.TerminalNode

func (*UpdatedElementContext) EnterRule

func (s *UpdatedElementContext) EnterRule(listener antlr.ParseTreeListener)

func (*UpdatedElementContext) ExitRule

func (s *UpdatedElementContext) ExitRule(listener antlr.ParseTreeListener)

func (*UpdatedElementContext) Expression

func (s *UpdatedElementContext) Expression() IExpressionContext

func (*UpdatedElementContext) FullColumnName

func (s *UpdatedElementContext) FullColumnName() IFullColumnNameContext

func (*UpdatedElementContext) GetParser

func (s *UpdatedElementContext) GetParser() antlr.Parser

func (*UpdatedElementContext) GetRuleContext

func (s *UpdatedElementContext) GetRuleContext() antlr.RuleContext

func (*UpdatedElementContext) IsUpdatedElementContext

func (*UpdatedElementContext) IsUpdatedElementContext()

func (*UpdatedElementContext) ToStringTree

func (s *UpdatedElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type UserDefinedMacroFunctionStatementBodyContext

type UserDefinedMacroFunctionStatementBodyContext struct {
	RoutineBodyContext
}

func (*UserDefinedMacroFunctionStatementBodyContext) AS

func (*UserDefinedMacroFunctionStatementBodyContext) Accept

func (*UserDefinedMacroFunctionStatementBodyContext) EnterRule

func (*UserDefinedMacroFunctionStatementBodyContext) ExitRule

func (*UserDefinedMacroFunctionStatementBodyContext) Expression

func (*UserDefinedMacroFunctionStatementBodyContext) GetRuleContext

func (*UserDefinedMacroFunctionStatementBodyContext) RETURN

type UserDefinedScalarFunctionCallContext

type UserDefinedScalarFunctionCallContext struct {
	FunctionCallContext
}

func (*UserDefinedScalarFunctionCallContext) Accept

func (s *UserDefinedScalarFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UserDefinedScalarFunctionCallContext) EnterRule

func (*UserDefinedScalarFunctionCallContext) ExitRule

func (*UserDefinedScalarFunctionCallContext) GetRuleContext

func (*UserDefinedScalarFunctionCallContext) LEFT_ROUND_BRACKET

func (*UserDefinedScalarFunctionCallContext) NamedOrUnnamedFunctionArgs

func (*UserDefinedScalarFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *UserDefinedScalarFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*UserDefinedScalarFunctionCallContext) UserDefinedScalarFunctionName

type UserDefinedScalarFunctionNameContext

type UserDefinedScalarFunctionNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUserDefinedScalarFunctionNameContext

func NewEmptyUserDefinedScalarFunctionNameContext() *UserDefinedScalarFunctionNameContext

func NewUserDefinedScalarFunctionNameContext

func NewUserDefinedScalarFunctionNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserDefinedScalarFunctionNameContext

func (*UserDefinedScalarFunctionNameContext) Accept

func (s *UserDefinedScalarFunctionNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UserDefinedScalarFunctionNameContext) DOUBLE_QUOTE_ID

func (*UserDefinedScalarFunctionNameContext) EnterRule

func (*UserDefinedScalarFunctionNameContext) ExitRule

func (*UserDefinedScalarFunctionNameContext) GetParser

func (*UserDefinedScalarFunctionNameContext) GetRuleContext

func (*UserDefinedScalarFunctionNameContext) ID

func (*UserDefinedScalarFunctionNameContext) IsUserDefinedScalarFunctionNameContext

func (*UserDefinedScalarFunctionNameContext) IsUserDefinedScalarFunctionNameContext()

func (*UserDefinedScalarFunctionNameContext) ToStringTree

func (s *UserDefinedScalarFunctionNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type UserVariablesContext

type UserVariablesContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUserVariablesContext

func NewEmptyUserVariablesContext() *UserVariablesContext

func NewUserVariablesContext

func NewUserVariablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UserVariablesContext

func (*UserVariablesContext) Accept

func (s *UserVariablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UserVariablesContext) AllCOMMA

func (s *UserVariablesContext) AllCOMMA() []antlr.TerminalNode

func (*UserVariablesContext) AllLOCAL_ID

func (s *UserVariablesContext) AllLOCAL_ID() []antlr.TerminalNode

func (*UserVariablesContext) COMMA

func (*UserVariablesContext) EnterRule

func (s *UserVariablesContext) EnterRule(listener antlr.ParseTreeListener)

func (*UserVariablesContext) ExitRule

func (s *UserVariablesContext) ExitRule(listener antlr.ParseTreeListener)

func (*UserVariablesContext) GetParser

func (s *UserVariablesContext) GetParser() antlr.Parser

func (*UserVariablesContext) GetRuleContext

func (s *UserVariablesContext) GetRuleContext() antlr.RuleContext

func (*UserVariablesContext) IsUserVariablesContext

func (*UserVariablesContext) IsUserVariablesContext()

func (*UserVariablesContext) LOCAL_ID

func (s *UserVariablesContext) LOCAL_ID(i int) antlr.TerminalNode

func (*UserVariablesContext) ToStringTree

func (s *UserVariablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type UtilityStatementContext

type UtilityStatementContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUtilityStatementContext

func NewEmptyUtilityStatementContext() *UtilityStatementContext

func NewUtilityStatementContext

func NewUtilityStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UtilityStatementContext

func (*UtilityStatementContext) Accept

func (s *UtilityStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UtilityStatementContext) EnterRule

func (s *UtilityStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*UtilityStatementContext) ExitRule

func (s *UtilityStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*UtilityStatementContext) FullDescribeStatement

func (s *UtilityStatementContext) FullDescribeStatement() IFullDescribeStatementContext

func (*UtilityStatementContext) GetParser

func (s *UtilityStatementContext) GetParser() antlr.Parser

func (*UtilityStatementContext) GetRuleContext

func (s *UtilityStatementContext) GetRuleContext() antlr.RuleContext

func (*UtilityStatementContext) HelpStatement

func (*UtilityStatementContext) IsUtilityStatementContext

func (*UtilityStatementContext) IsUtilityStatementContext()

func (*UtilityStatementContext) SimpleDescribeStatement

func (s *UtilityStatementContext) SimpleDescribeStatement() ISimpleDescribeStatementContext

func (*UtilityStatementContext) ToStringTree

func (s *UtilityStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ValuesFunctionCallContext

type ValuesFunctionCallContext struct {
	SpecificFunctionContext
}

func NewValuesFunctionCallContext

func NewValuesFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ValuesFunctionCallContext

func (*ValuesFunctionCallContext) Accept

func (s *ValuesFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ValuesFunctionCallContext) EnterRule

func (s *ValuesFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*ValuesFunctionCallContext) ExitRule

func (s *ValuesFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*ValuesFunctionCallContext) FullColumnName

func (*ValuesFunctionCallContext) GetRuleContext

func (s *ValuesFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*ValuesFunctionCallContext) LEFT_ROUND_BRACKET

func (s *ValuesFunctionCallContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*ValuesFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *ValuesFunctionCallContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*ValuesFunctionCallContext) VALUES

type VariableClauseContext

type VariableClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVariableClauseContext

func NewEmptyVariableClauseContext() *VariableClauseContext

func NewVariableClauseContext

func NewVariableClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableClauseContext

func (*VariableClauseContext) AT_SIGN

func (*VariableClauseContext) Accept

func (s *VariableClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VariableClauseContext) AllAT_SIGN

func (s *VariableClauseContext) AllAT_SIGN() []antlr.TerminalNode

func (*VariableClauseContext) EnterRule

func (s *VariableClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*VariableClauseContext) ExitRule

func (s *VariableClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*VariableClauseContext) GLOBAL

func (*VariableClauseContext) GetParser

func (s *VariableClauseContext) GetParser() antlr.Parser

func (*VariableClauseContext) GetRuleContext

func (s *VariableClauseContext) GetRuleContext() antlr.RuleContext

func (*VariableClauseContext) IsVariableClauseContext

func (*VariableClauseContext) IsVariableClauseContext()

func (*VariableClauseContext) LOCAL

func (*VariableClauseContext) LOCAL_ID

func (*VariableClauseContext) SESSION

func (*VariableClauseContext) ToStringTree

func (s *VariableClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*VariableClauseContext) Uid

type VectorElementTypeContext

type VectorElementTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVectorElementTypeContext

func NewEmptyVectorElementTypeContext() *VectorElementTypeContext

func NewVectorElementTypeContext

func NewVectorElementTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VectorElementTypeContext

func (*VectorElementTypeContext) Accept

func (s *VectorElementTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VectorElementTypeContext) DOUBLE

func (*VectorElementTypeContext) EnterRule

func (s *VectorElementTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*VectorElementTypeContext) ExitRule

func (s *VectorElementTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*VectorElementTypeContext) FLOAT

func (*VectorElementTypeContext) GetParser

func (s *VectorElementTypeContext) GetParser() antlr.Parser

func (*VectorElementTypeContext) GetRuleContext

func (s *VectorElementTypeContext) GetRuleContext() antlr.RuleContext

func (*VectorElementTypeContext) HALF

func (*VectorElementTypeContext) IsVectorElementTypeContext

func (*VectorElementTypeContext) IsVectorElementTypeContext()

func (*VectorElementTypeContext) ToStringTree

func (s *VectorElementTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type VectorEngineContext

type VectorEngineContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVectorEngineContext

func NewEmptyVectorEngineContext() *VectorEngineContext

func NewVectorEngineContext

func NewVectorEngineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VectorEngineContext

func (*VectorEngineContext) Accept

func (s *VectorEngineContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VectorEngineContext) EnterRule

func (s *VectorEngineContext) EnterRule(listener antlr.ParseTreeListener)

func (*VectorEngineContext) ExitRule

func (s *VectorEngineContext) ExitRule(listener antlr.ParseTreeListener)

func (*VectorEngineContext) GUARDIANN

func (s *VectorEngineContext) GUARDIANN() antlr.TerminalNode

func (*VectorEngineContext) GetParser

func (s *VectorEngineContext) GetParser() antlr.Parser

func (*VectorEngineContext) GetRuleContext

func (s *VectorEngineContext) GetRuleContext() antlr.RuleContext

func (*VectorEngineContext) HNSW

func (*VectorEngineContext) IsVectorEngineContext

func (*VectorEngineContext) IsVectorEngineContext()

func (*VectorEngineContext) SPFRESH

func (s *VectorEngineContext) SPFRESH() antlr.TerminalNode

func (*VectorEngineContext) ToStringTree

func (s *VectorEngineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type VectorIndexDefinitionContext

type VectorIndexDefinitionContext struct {
	IndexDefinitionContext
	// contains filtered or unexported fields
}

func NewVectorIndexDefinitionContext

func NewVectorIndexDefinitionContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *VectorIndexDefinitionContext

func (*VectorIndexDefinitionContext) Accept

func (s *VectorIndexDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VectorIndexDefinitionContext) EnterRule

func (s *VectorIndexDefinitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*VectorIndexDefinitionContext) ExitRule

func (*VectorIndexDefinitionContext) FullId

func (*VectorIndexDefinitionContext) GetEngine

func (*VectorIndexDefinitionContext) GetIndexName

func (s *VectorIndexDefinitionContext) GetIndexName() IUidContext

func (*VectorIndexDefinitionContext) GetRuleContext

func (s *VectorIndexDefinitionContext) GetRuleContext() antlr.RuleContext

func (*VectorIndexDefinitionContext) GetSource

func (*VectorIndexDefinitionContext) INDEX

func (*VectorIndexDefinitionContext) IncludeClause

func (*VectorIndexDefinitionContext) IndexColumnList

func (*VectorIndexDefinitionContext) IndexPartitionClause

func (*VectorIndexDefinitionContext) ON

func (*VectorIndexDefinitionContext) SetEngine

func (*VectorIndexDefinitionContext) SetIndexName

func (s *VectorIndexDefinitionContext) SetIndexName(v IUidContext)

func (*VectorIndexDefinitionContext) SetSource

func (*VectorIndexDefinitionContext) USING

func (*VectorIndexDefinitionContext) Uid

func (*VectorIndexDefinitionContext) VECTOR

func (*VectorIndexDefinitionContext) VectorEngine

func (*VectorIndexDefinitionContext) VectorIndexOptions

type VectorIndexOptionContext

type VectorIndexOptionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVectorIndexOptionContext

func NewEmptyVectorIndexOptionContext() *VectorIndexOptionContext

func NewVectorIndexOptionContext

func NewVectorIndexOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VectorIndexOptionContext

func (*VectorIndexOptionContext) Accept

func (s *VectorIndexOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VectorIndexOptionContext) EQUAL_SYMBOL

func (s *VectorIndexOptionContext) EQUAL_SYMBOL() antlr.TerminalNode

func (*VectorIndexOptionContext) EnterRule

func (s *VectorIndexOptionContext) EnterRule(listener antlr.ParseTreeListener)

func (*VectorIndexOptionContext) ExitRule

func (s *VectorIndexOptionContext) ExitRule(listener antlr.ParseTreeListener)

func (*VectorIndexOptionContext) GetOptionName

func (s *VectorIndexOptionContext) GetOptionName() ISimpleIdContext

func (*VectorIndexOptionContext) GetOptionValue

func (*VectorIndexOptionContext) GetParser

func (s *VectorIndexOptionContext) GetParser() antlr.Parser

func (*VectorIndexOptionContext) GetRuleContext

func (s *VectorIndexOptionContext) GetRuleContext() antlr.RuleContext

func (*VectorIndexOptionContext) IsVectorIndexOptionContext

func (*VectorIndexOptionContext) IsVectorIndexOptionContext()

func (*VectorIndexOptionContext) SetOptionName

func (s *VectorIndexOptionContext) SetOptionName(v ISimpleIdContext)

func (*VectorIndexOptionContext) SetOptionValue

func (*VectorIndexOptionContext) SimpleId

func (*VectorIndexOptionContext) ToStringTree

func (s *VectorIndexOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*VectorIndexOptionContext) VectorIndexOptionValue

func (s *VectorIndexOptionContext) VectorIndexOptionValue() IVectorIndexOptionValueContext

type VectorIndexOptionValueContext

type VectorIndexOptionValueContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVectorIndexOptionValueContext

func NewEmptyVectorIndexOptionValueContext() *VectorIndexOptionValueContext

func NewVectorIndexOptionValueContext

func NewVectorIndexOptionValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VectorIndexOptionValueContext

func (*VectorIndexOptionValueContext) Accept

func (s *VectorIndexOptionValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VectorIndexOptionValueContext) BooleanLiteral

func (*VectorIndexOptionValueContext) DECIMAL_LITERAL

func (s *VectorIndexOptionValueContext) DECIMAL_LITERAL() antlr.TerminalNode

func (*VectorIndexOptionValueContext) EnterRule

func (s *VectorIndexOptionValueContext) EnterRule(listener antlr.ParseTreeListener)

func (*VectorIndexOptionValueContext) ExitRule

func (*VectorIndexOptionValueContext) GetParser

func (*VectorIndexOptionValueContext) GetRuleContext

func (s *VectorIndexOptionValueContext) GetRuleContext() antlr.RuleContext

func (*VectorIndexOptionValueContext) HnswMetric

func (*VectorIndexOptionValueContext) IsVectorIndexOptionValueContext

func (*VectorIndexOptionValueContext) IsVectorIndexOptionValueContext()

func (*VectorIndexOptionValueContext) REAL_LITERAL

func (*VectorIndexOptionValueContext) ToStringTree

func (s *VectorIndexOptionValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type VectorIndexOptionsContext

type VectorIndexOptionsContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVectorIndexOptionsContext

func NewEmptyVectorIndexOptionsContext() *VectorIndexOptionsContext

func NewVectorIndexOptionsContext

func NewVectorIndexOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VectorIndexOptionsContext

func (*VectorIndexOptionsContext) Accept

func (s *VectorIndexOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VectorIndexOptionsContext) AllCOMMA

func (*VectorIndexOptionsContext) AllVectorIndexOption

func (s *VectorIndexOptionsContext) AllVectorIndexOption() []IVectorIndexOptionContext

func (*VectorIndexOptionsContext) COMMA

func (*VectorIndexOptionsContext) EnterRule

func (s *VectorIndexOptionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*VectorIndexOptionsContext) ExitRule

func (s *VectorIndexOptionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*VectorIndexOptionsContext) GetParser

func (s *VectorIndexOptionsContext) GetParser() antlr.Parser

func (*VectorIndexOptionsContext) GetRuleContext

func (s *VectorIndexOptionsContext) GetRuleContext() antlr.RuleContext

func (*VectorIndexOptionsContext) IsVectorIndexOptionsContext

func (*VectorIndexOptionsContext) IsVectorIndexOptionsContext()

func (*VectorIndexOptionsContext) LEFT_ROUND_BRACKET

func (s *VectorIndexOptionsContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*VectorIndexOptionsContext) OPTIONS

func (*VectorIndexOptionsContext) RIGHT_ROUND_BRACKET

func (s *VectorIndexOptionsContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*VectorIndexOptionsContext) ToStringTree

func (s *VectorIndexOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*VectorIndexOptionsContext) VectorIndexOption

type VectorTypeContext

type VectorTypeContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVectorTypeContext

func NewEmptyVectorTypeContext() *VectorTypeContext

func NewVectorTypeContext

func NewVectorTypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VectorTypeContext

func (*VectorTypeContext) Accept

func (s *VectorTypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VectorTypeContext) COMMA

func (*VectorTypeContext) DECIMAL_LITERAL

func (s *VectorTypeContext) DECIMAL_LITERAL() antlr.TerminalNode

func (*VectorTypeContext) EnterRule

func (s *VectorTypeContext) EnterRule(listener antlr.ParseTreeListener)

func (*VectorTypeContext) ExitRule

func (s *VectorTypeContext) ExitRule(listener antlr.ParseTreeListener)

func (*VectorTypeContext) GetDimensions

func (s *VectorTypeContext) GetDimensions() antlr.Token

func (*VectorTypeContext) GetElementType

func (s *VectorTypeContext) GetElementType() IVectorElementTypeContext

func (*VectorTypeContext) GetParser

func (s *VectorTypeContext) GetParser() antlr.Parser

func (*VectorTypeContext) GetRuleContext

func (s *VectorTypeContext) GetRuleContext() antlr.RuleContext

func (*VectorTypeContext) IsVectorTypeContext

func (*VectorTypeContext) IsVectorTypeContext()

func (*VectorTypeContext) LEFT_ROUND_BRACKET

func (s *VectorTypeContext) LEFT_ROUND_BRACKET() antlr.TerminalNode

func (*VectorTypeContext) RIGHT_ROUND_BRACKET

func (s *VectorTypeContext) RIGHT_ROUND_BRACKET() antlr.TerminalNode

func (*VectorTypeContext) SetDimensions

func (s *VectorTypeContext) SetDimensions(v antlr.Token)

func (*VectorTypeContext) SetElementType

func (s *VectorTypeContext) SetElementType(v IVectorElementTypeContext)

func (*VectorTypeContext) ToStringTree

func (s *VectorTypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*VectorTypeContext) VECTOR

func (s *VectorTypeContext) VECTOR() antlr.TerminalNode

func (*VectorTypeContext) VectorElementType

func (s *VectorTypeContext) VectorElementType() IVectorElementTypeContext

type ViewDefinitionContext

type ViewDefinitionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyViewDefinitionContext

func NewEmptyViewDefinitionContext() *ViewDefinitionContext

func NewViewDefinitionContext

func NewViewDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ViewDefinitionContext

func (*ViewDefinitionContext) AS

func (*ViewDefinitionContext) Accept

func (s *ViewDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ViewDefinitionContext) EnterRule

func (s *ViewDefinitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ViewDefinitionContext) ExitRule

func (s *ViewDefinitionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ViewDefinitionContext) FullId

func (*ViewDefinitionContext) GetParser

func (s *ViewDefinitionContext) GetParser() antlr.Parser

func (*ViewDefinitionContext) GetRuleContext

func (s *ViewDefinitionContext) GetRuleContext() antlr.RuleContext

func (*ViewDefinitionContext) GetViewName

func (s *ViewDefinitionContext) GetViewName() IFullIdContext

func (*ViewDefinitionContext) GetViewQuery

func (s *ViewDefinitionContext) GetViewQuery() IQueryContext

func (*ViewDefinitionContext) IsViewDefinitionContext

func (*ViewDefinitionContext) IsViewDefinitionContext()

func (*ViewDefinitionContext) Query

func (*ViewDefinitionContext) SetViewName

func (s *ViewDefinitionContext) SetViewName(v IFullIdContext)

func (*ViewDefinitionContext) SetViewQuery

func (s *ViewDefinitionContext) SetViewQuery(v IQueryContext)

func (*ViewDefinitionContext) ToStringTree

func (s *ViewDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ViewDefinitionContext) VIEW

type WeightFunctionCallContext

type WeightFunctionCallContext struct {
	SpecificFunctionContext
	// contains filtered or unexported fields
}

func NewWeightFunctionCallContext

func NewWeightFunctionCallContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *WeightFunctionCallContext

func (*WeightFunctionCallContext) AS

func (*WeightFunctionCallContext) Accept

func (s *WeightFunctionCallContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*WeightFunctionCallContext) AllLEFT_ROUND_BRACKET

func (s *WeightFunctionCallContext) AllLEFT_ROUND_BRACKET() []antlr.TerminalNode

func (*WeightFunctionCallContext) AllRIGHT_ROUND_BRACKET

func (s *WeightFunctionCallContext) AllRIGHT_ROUND_BRACKET() []antlr.TerminalNode

func (*WeightFunctionCallContext) BINARY

func (*WeightFunctionCallContext) CHAR

func (*WeightFunctionCallContext) DecimalLiteral

func (*WeightFunctionCallContext) EnterRule

func (s *WeightFunctionCallContext) EnterRule(listener antlr.ParseTreeListener)

func (*WeightFunctionCallContext) ExitRule

func (s *WeightFunctionCallContext) ExitRule(listener antlr.ParseTreeListener)

func (*WeightFunctionCallContext) Expression

func (*WeightFunctionCallContext) GetRuleContext

func (s *WeightFunctionCallContext) GetRuleContext() antlr.RuleContext

func (*WeightFunctionCallContext) GetStringFormat

func (s *WeightFunctionCallContext) GetStringFormat() antlr.Token

func (*WeightFunctionCallContext) LEFT_ROUND_BRACKET

func (s *WeightFunctionCallContext) LEFT_ROUND_BRACKET(i int) antlr.TerminalNode

func (*WeightFunctionCallContext) LevelsInWeightString

func (s *WeightFunctionCallContext) LevelsInWeightString() ILevelsInWeightStringContext

func (*WeightFunctionCallContext) RIGHT_ROUND_BRACKET

func (s *WeightFunctionCallContext) RIGHT_ROUND_BRACKET(i int) antlr.TerminalNode

func (*WeightFunctionCallContext) SetStringFormat

func (s *WeightFunctionCallContext) SetStringFormat(v antlr.Token)

func (*WeightFunctionCallContext) StringLiteral

func (*WeightFunctionCallContext) WEIGHT_STRING

func (s *WeightFunctionCallContext) WEIGHT_STRING() antlr.TerminalNode

type WhereExprContext

type WhereExprContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWhereExprContext

func NewEmptyWhereExprContext() *WhereExprContext

func NewWhereExprContext

func NewWhereExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WhereExprContext

func (*WhereExprContext) Accept

func (s *WhereExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*WhereExprContext) EnterRule

func (s *WhereExprContext) EnterRule(listener antlr.ParseTreeListener)

func (*WhereExprContext) ExitRule

func (s *WhereExprContext) ExitRule(listener antlr.ParseTreeListener)

func (*WhereExprContext) Expression

func (s *WhereExprContext) Expression() IExpressionContext

func (*WhereExprContext) GetParser

func (s *WhereExprContext) GetParser() antlr.Parser

func (*WhereExprContext) GetRuleContext

func (s *WhereExprContext) GetRuleContext() antlr.RuleContext

func (*WhereExprContext) IsWhereExprContext

func (*WhereExprContext) IsWhereExprContext()

func (*WhereExprContext) ToStringTree

func (s *WhereExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type WindowNameContext

type WindowNameContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWindowNameContext

func NewEmptyWindowNameContext() *WindowNameContext

func NewWindowNameContext

func NewWindowNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowNameContext

func (*WindowNameContext) Accept

func (s *WindowNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*WindowNameContext) EnterRule

func (s *WindowNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*WindowNameContext) ExitRule

func (s *WindowNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*WindowNameContext) GetParser

func (s *WindowNameContext) GetParser() antlr.Parser

func (*WindowNameContext) GetRuleContext

func (s *WindowNameContext) GetRuleContext() antlr.RuleContext

func (*WindowNameContext) IsWindowNameContext

func (*WindowNameContext) IsWindowNameContext()

func (*WindowNameContext) ToStringTree

func (s *WindowNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*WindowNameContext) Uid

func (s *WindowNameContext) Uid() IUidContext

type WindowOptionContext

type WindowOptionContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWindowOptionContext

func NewEmptyWindowOptionContext() *WindowOptionContext

func NewWindowOptionContext

func NewWindowOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowOptionContext

func (*WindowOptionContext) Accept

func (s *WindowOptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*WindowOptionContext) DECIMAL_LITERAL

func (s *WindowOptionContext) DECIMAL_LITERAL() antlr.TerminalNode
func (s *WindowOptionContext) EF_SEARCH() antlr.TerminalNode

func (*WindowOptionContext) EQUAL_SYMBOL

func (s *WindowOptionContext) EQUAL_SYMBOL() antlr.TerminalNode

func (*WindowOptionContext) EnterRule

func (s *WindowOptionContext) EnterRule(listener antlr.ParseTreeListener)

func (*WindowOptionContext) ExitRule

func (s *WindowOptionContext) ExitRule(listener antlr.ParseTreeListener)

func (*WindowOptionContext) GetEfSearch

func (s *WindowOptionContext) GetEfSearch() antlr.Token

func (*WindowOptionContext) GetParser

func (s *WindowOptionContext) GetParser() antlr.Parser

func (*WindowOptionContext) GetRuleContext

func (s *WindowOptionContext) GetRuleContext() antlr.RuleContext

func (*WindowOptionContext) IsWindowOptionContext

func (*WindowOptionContext) IsWindowOptionContext()

func (*WindowOptionContext) SetEfSearch

func (s *WindowOptionContext) SetEfSearch(v antlr.Token)

func (*WindowOptionContext) ToStringTree

func (s *WindowOptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type WindowOptionsClauseContext

type WindowOptionsClauseContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWindowOptionsClauseContext

func NewEmptyWindowOptionsClauseContext() *WindowOptionsClauseContext

func NewWindowOptionsClauseContext

func NewWindowOptionsClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowOptionsClauseContext

func (*WindowOptionsClauseContext) Accept

func (s *WindowOptionsClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*WindowOptionsClauseContext) AllCOMMA

func (*WindowOptionsClauseContext) AllWindowOption

func (s *WindowOptionsClauseContext) AllWindowOption() []IWindowOptionContext

func (*WindowOptionsClauseContext) COMMA

func (*WindowOptionsClauseContext) EnterRule

func (s *WindowOptionsClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*WindowOptionsClauseContext) ExitRule

func (s *WindowOptionsClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*WindowOptionsClauseContext) GetParser

func (s *WindowOptionsClauseContext) GetParser() antlr.Parser

func (*WindowOptionsClauseContext) GetRuleContext

func (s *WindowOptionsClauseContext) GetRuleContext() antlr.RuleContext

func (*WindowOptionsClauseContext) IsWindowOptionsClauseContext

func (*WindowOptionsClauseContext) IsWindowOptionsClauseContext()

func (*WindowOptionsClauseContext) OPTIONS

func (*WindowOptionsClauseContext) ToStringTree

func (s *WindowOptionsClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*WindowOptionsClauseContext) WindowOption

type WindowSpecContext

type WindowSpecContext struct {
	antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWindowSpecContext

func NewEmptyWindowSpecContext() *WindowSpecContext

func NewWindowSpecContext

func NewWindowSpecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *WindowSpecContext

func (*WindowSpecContext) Accept

func (s *WindowSpecContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*WindowSpecContext) EnterRule

func (s *WindowSpecContext) EnterRule(listener antlr.ParseTreeListener)

func (*WindowSpecContext) ExitRule

func (s *WindowSpecContext) ExitRule(listener antlr.ParseTreeListener)

func (*WindowSpecContext) GetParser

func (s *WindowSpecContext) GetParser() antlr.Parser

func (*WindowSpecContext) GetRuleContext

func (s *WindowSpecContext) GetRuleContext() antlr.RuleContext

func (*WindowSpecContext) IsWindowSpecContext

func (*WindowSpecContext) IsWindowSpecContext()

func (*WindowSpecContext) OrderByClause

func (s *WindowSpecContext) OrderByClause() IOrderByClauseContext

func (*WindowSpecContext) PartitionClause

func (s *WindowSpecContext) PartitionClause() IPartitionClauseContext

func (*WindowSpecContext) ToStringTree

func (s *WindowSpecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*WindowSpecContext) WindowName

func (s *WindowSpecContext) WindowName() IWindowNameContext

func (*WindowSpecContext) WindowOptionsClause

func (s *WindowSpecContext) WindowOptionsClause() IWindowOptionsClauseContext

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL