antlrgen

package
v0.0.0-...-741f41f Latest Latest
Warning

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

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

Documentation

Index

Constants

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

RelationalLexer tokens.

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

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

RelationalParser rules.

View Source
const RelationalLexerMYSQLCOMMENT = 2

RelationalLexerMYSQLCOMMENT is the RelationalLexer channel.

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 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 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 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 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 InitEmptyQueryOptionContext

func InitEmptyQueryOptionContext(p *QueryOptionContext)

func InitEmptyQueryOptionsContext

func InitEmptyQueryOptionsContext(p *QueryOptionsContext)

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 InitEmptyReturnValueContext

func InitEmptyReturnValueContext(p *ReturnValueContext)

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 InitEmptySqlReturnStatementContext

func InitEmptySqlReturnStatementContext(p *SqlReturnStatementContext)

func InitEmptyStartTransactionContext

func InitEmptyStartTransactionContext(p *StartTransactionContext)

func InitEmptyStatementContext

func InitEmptyStatementContext(p *StatementContext)

func InitEmptyStatementsContext

func InitEmptyStatementsContext(p *StatementsContext)

func InitEmptyStringLiteralContext

func InitEmptyStringLiteralContext(p *StringLiteralContext)

func InitEmptyStructDefinitionContext

func InitEmptyStructDefinitionContext(p *StructDefinitionContext)

func InitEmptyTableDefinitionContext

func InitEmptyTableDefinitionContext(p *TableDefinitionContext)

func InitEmptyTableFunctionArgsContext

func InitEmptyTableFunctionArgsContext(p *TableFunctionArgsContext)

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 InitEmptyVectorIndexOptionContext

func InitEmptyVectorIndexOptionContext(p *VectorIndexOptionContext)

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 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 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) AVG

func (*AggregateWindowedFunctionContext) Accept

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

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) ORDER

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) 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) 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) EnterExpressionBody

func (s *BaseRelationalParserListener) EnterExpressionBody(ctx *ExpressionBodyContext)

EnterExpressionBody is called when production expressionBody 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) 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) 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) EnterQueryOption

func (s *BaseRelationalParserListener) EnterQueryOption(ctx *QueryOptionContext)

EnterQueryOption is called when production queryOption is entered.

func (*BaseRelationalParserListener) EnterQueryOptions

func (s *BaseRelationalParserListener) EnterQueryOptions(ctx *QueryOptionsContext)

EnterQueryOptions is called when production queryOptions 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) EnterReturnValue

func (s *BaseRelationalParserListener) EnterReturnValue(ctx *ReturnValueContext)

EnterReturnValue is called when production returnValue 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) EnterSqlReturnStatement

func (s *BaseRelationalParserListener) EnterSqlReturnStatement(ctx *SqlReturnStatementContext)

EnterSqlReturnStatement is called when production sqlReturnStatement 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) EnterStatements

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

EnterStatements is called when production statements 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) EnterTableFunctionArgs

func (s *BaseRelationalParserListener) EnterTableFunctionArgs(ctx *TableFunctionArgsContext)

EnterTableFunctionArgs is called when production tableFunctionArgs 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) 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) EnterUserDefinedScalarFunctionStatementBody

func (s *BaseRelationalParserListener) EnterUserDefinedScalarFunctionStatementBody(ctx *UserDefinedScalarFunctionStatementBodyContext)

EnterUserDefinedScalarFunctionStatementBody is called when production userDefinedScalarFunctionStatementBody 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) 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) 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) 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) 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) ExitExpressionBody

func (s *BaseRelationalParserListener) ExitExpressionBody(ctx *ExpressionBodyContext)

ExitExpressionBody is called when production expressionBody 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) 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) 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) ExitQueryOption

func (s *BaseRelationalParserListener) ExitQueryOption(ctx *QueryOptionContext)

ExitQueryOption is called when production queryOption is exited.

func (*BaseRelationalParserListener) ExitQueryOptions

func (s *BaseRelationalParserListener) ExitQueryOptions(ctx *QueryOptionsContext)

ExitQueryOptions is called when production queryOptions 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) ExitReturnValue

func (s *BaseRelationalParserListener) ExitReturnValue(ctx *ReturnValueContext)

ExitReturnValue is called when production returnValue 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) ExitSqlReturnStatement

func (s *BaseRelationalParserListener) ExitSqlReturnStatement(ctx *SqlReturnStatementContext)

ExitSqlReturnStatement is called when production sqlReturnStatement 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) ExitStatements

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

ExitStatements is called when production statements 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) ExitTableFunctionArgs

func (s *BaseRelationalParserListener) ExitTableFunctionArgs(ctx *TableFunctionArgsContext)

ExitTableFunctionArgs is called when production tableFunctionArgs 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) 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) ExitUserDefinedScalarFunctionStatementBody

func (s *BaseRelationalParserListener) ExitUserDefinedScalarFunctionStatementBody(ctx *UserDefinedScalarFunctionStatementBodyContext)

ExitUserDefinedScalarFunctionStatementBody is called when production userDefinedScalarFunctionStatementBody 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) 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) 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) 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) 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) VisitExpressionBody

func (v *BaseRelationalParserVisitor) VisitExpressionBody(ctx *ExpressionBodyContext) 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) 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) 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) VisitQueryOption

func (v *BaseRelationalParserVisitor) VisitQueryOption(ctx *QueryOptionContext) interface{}

func (*BaseRelationalParserVisitor) VisitQueryOptions

func (v *BaseRelationalParserVisitor) VisitQueryOptions(ctx *QueryOptionsContext) 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) VisitReturnValue

func (v *BaseRelationalParserVisitor) VisitReturnValue(ctx *ReturnValueContext) 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) VisitSqlReturnStatement

func (v *BaseRelationalParserVisitor) VisitSqlReturnStatement(ctx *SqlReturnStatementContext) 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) VisitStatements

func (v *BaseRelationalParserVisitor) VisitStatements(ctx *StatementsContext) 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) VisitTableFunctionArgs

func (v *BaseRelationalParserVisitor) VisitTableFunctionArgs(ctx *TableFunctionArgsContext) 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) VisitUserDefinedScalarFunctionCall

func (v *BaseRelationalParserVisitor) VisitUserDefinedScalarFunctionCall(ctx *UserDefinedScalarFunctionCallContext) interface{}

func (*BaseRelationalParserVisitor) VisitUserDefinedScalarFunctionName

func (v *BaseRelationalParserVisitor) VisitUserDefinedScalarFunctionName(ctx *UserDefinedScalarFunctionNameContext) interface{}

func (*BaseRelationalParserVisitor) VisitUserDefinedScalarFunctionStatementBody

func (v *BaseRelationalParserVisitor) VisitUserDefinedScalarFunctionStatementBody(ctx *UserDefinedScalarFunctionStatementBodyContext) 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) VisitVectorIndexDefinition

func (v *BaseRelationalParserVisitor) VisitVectorIndexDefinition(ctx *VectorIndexDefinitionContext) interface{}

func (*BaseRelationalParserVisitor) VisitVectorIndexOption

func (v *BaseRelationalParserVisitor) VisitVectorIndexOption(ctx *VectorIndexOptionContext) 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 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) QueryOptions

func (s *DeleteStatementContext) QueryOptions() IQueryOptionsContext

func (*DeleteStatementContext) RETURNING

func (s *DeleteStatementContext) RETURNING() antlr.TerminalNode

func (*DeleteStatementContext) SelectElements

func (s *DeleteStatementContext) SelectElements() ISelectElementsContext

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) 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) QueryOptions

func (*ExecuteContinuationStatementContext) SetPackageBytes

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 ExpressionBodyContext

type ExpressionBodyContext struct {
	RoutineBodyContext
}

func NewExpressionBodyContext

func NewExpressionBodyContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ExpressionBodyContext

func (*ExpressionBodyContext) Accept

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

func (*ExpressionBodyContext) EnterRule

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

func (*ExpressionBodyContext) ExitRule

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

func (*ExpressionBodyContext) GetRuleContext

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

func (*ExpressionBodyContext) SqlReturnStatement

func (s *ExpressionBodyContext) SqlReturnStatement() ISqlReturnStatementContext

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) 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 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
	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 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
	QueryOptions() IQueryOptionsContext

	// 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
	QueryOptions() IQueryOptionsContext

	// 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

	// 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
	QueryOptions() IQueryOptionsContext
	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
	ACCOUNT() antlr.TerminalNode
	ACTION() antlr.TerminalNode
	ADMIN() antlr.TerminalNode
	AFTER() antlr.TerminalNode
	AGGREGATE() antlr.TerminalNode
	ALGORITHM() antlr.TerminalNode
	ANY() 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
	FULL() 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
	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 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 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 IQueryOptionContext

type IQueryOptionContext 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
	EF_SEARCH() antlr.TerminalNode
	DecimalLiteral() IDecimalLiteralContext

	// IsQueryOptionContext differentiates from other interfaces.
	IsQueryOptionContext()
}

IQueryOptionContext is an interface to support dynamic dispatch.

type IQueryOptionsContext

type IQueryOptionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	OPTIONS() antlr.TerminalNode
	LEFT_ROUND_BRACKET() antlr.TerminalNode
	AllQueryOption() []IQueryOptionContext
	QueryOption(i int) IQueryOptionContext
	RIGHT_ROUND_BRACKET() antlr.TerminalNode
	AllCOMMA() []antlr.TerminalNode
	COMMA(i int) antlr.TerminalNode

	// IsQueryOptionsContext differentiates from other interfaces.
	IsQueryOptionsContext()
}

IQueryOptionsContext 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 IReturnValueContext

type IReturnValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	Expression() IExpressionContext

	// IsReturnValueContext differentiates from other interfaces.
	IsReturnValueContext()
}

IReturnValueContext 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
	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

	// 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 ISqlReturnStatementContext

type ISqlReturnStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// Getter signatures
	RETURN() antlr.TerminalNode
	ReturnValue() IReturnValueContext

	// IsSqlReturnStatementContext differentiates from other interfaces.
	IsSqlReturnStatementContext()
}

ISqlReturnStatementContext 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 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 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 ITableFunctionArgsContext

type ITableFunctionArgsContext 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

	// IsTableFunctionArgsContext differentiates from other interfaces.
	IsTableFunctionArgsContext()
}

ITableFunctionArgsContext 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
	TableFunctionArgs() ITableFunctionArgsContext
	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

	// 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
	QueryOptions() IQueryOptionsContext
	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 IVectorIndexOptionContext

type IVectorIndexOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetEfConstruction returns the efConstruction token.
	GetEfConstruction() antlr.Token

	// GetConnectivity returns the connectivity token.
	GetConnectivity() antlr.Token

	// GetMMax returns the mMax token.
	GetMMax() antlr.Token

	// GetMMaxZero returns the mMaxZero token.
	GetMMaxZero() antlr.Token

	// GetMaintainStatsProbability returns the maintainStatsProbability token.
	GetMaintainStatsProbability() antlr.Token

	// GetRabitQNumExBits returns the rabitQNumExBits token.
	GetRabitQNumExBits() antlr.Token

	// GetStatsProbability returns the statsProbability token.
	GetStatsProbability() antlr.Token

	// GetStatsThreshold returns the statsThreshold token.
	GetStatsThreshold() antlr.Token

	// SetEfConstruction sets the efConstruction token.
	SetEfConstruction(antlr.Token)

	// SetConnectivity sets the connectivity token.
	SetConnectivity(antlr.Token)

	// SetMMax sets the mMax token.
	SetMMax(antlr.Token)

	// SetMMaxZero sets the mMaxZero token.
	SetMMaxZero(antlr.Token)

	// SetMaintainStatsProbability sets the maintainStatsProbability token.
	SetMaintainStatsProbability(antlr.Token)

	// SetRabitQNumExBits sets the rabitQNumExBits token.
	SetRabitQNumExBits(antlr.Token)

	// SetStatsProbability sets the statsProbability token.
	SetStatsProbability(antlr.Token)

	// SetStatsThreshold sets the statsThreshold token.
	SetStatsThreshold(antlr.Token)

	// GetMetric returns the metric rule contexts.
	GetMetric() IHnswMetricContext

	// GetUseRabitQ returns the useRabitQ rule contexts.
	GetUseRabitQ() IBooleanLiteralContext

	// SetMetric sets the metric rule contexts.
	SetMetric(IHnswMetricContext)

	// SetUseRabitQ sets the useRabitQ rule contexts.
	SetUseRabitQ(IBooleanLiteralContext)

	// Getter signatures
	EF_CONSTRUCTION() antlr.TerminalNode
	EQUAL_SYMBOL() antlr.TerminalNode
	DECIMAL_LITERAL() antlr.TerminalNode
	CONNECTIVITY() antlr.TerminalNode
	M_MAX() antlr.TerminalNode
	M_MAX_0() antlr.TerminalNode
	MAINTAIN_STATS_PROBABILITY() antlr.TerminalNode
	REAL_LITERAL() antlr.TerminalNode
	METRIC() antlr.TerminalNode
	HnswMetric() IHnswMetricContext
	RABITQ_NUM_EX_BITS() antlr.TerminalNode
	SAMPLE_VECTOR_STATS_PROBABILITY() antlr.TerminalNode
	STATS_THRESHOLD() antlr.TerminalNode
	USE_RABITQ() antlr.TerminalNode
	BooleanLiteral() IBooleanLiteralContext

	// IsVectorIndexOptionContext differentiates from other interfaces.
	IsVectorIndexOptionContext()
}

IVectorIndexOptionContext 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) QueryOptions

func (s *InsertStatementContext) QueryOptions() IQueryOptionsContext

func (*InsertStatementContext) SetColumns

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) 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) 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) 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) FULL

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) 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) 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) 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) 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) 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) 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) 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) 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) AllSTRING_LITERAL

func (s *LikePredicateContext) AllSTRING_LITERAL() []antlr.TerminalNode

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() antlr.Token

func (*LikePredicateContext) GetRuleContext

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

func (*LikePredicateContext) LIKE

func (*LikePredicateContext) NOT

func (*LikePredicateContext) STRING_LITERAL

func (s *LikePredicateContext) STRING_LITERAL(i int) antlr.TerminalNode

func (*LikePredicateContext) SetEscape

func (s *LikePredicateContext) SetEscape(v antlr.Token)

func (*LikePredicateContext) SetPattern

func (s *LikePredicateContext) SetPattern(v antlr.Token)

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 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 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 QueryOptionContext

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

func NewEmptyQueryOptionContext

func NewEmptyQueryOptionContext() *QueryOptionContext

func NewQueryOptionContext

func NewQueryOptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryOptionContext

func (*QueryOptionContext) Accept

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

func (*QueryOptionContext) DRY

func (*QueryOptionContext) DecimalLiteral

func (s *QueryOptionContext) DecimalLiteral() IDecimalLiteralContext
func (s *QueryOptionContext) EF_SEARCH() antlr.TerminalNode

func (*QueryOptionContext) EnterRule

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

func (*QueryOptionContext) ExitRule

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

func (*QueryOptionContext) GetParser

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

func (*QueryOptionContext) GetRuleContext

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

func (*QueryOptionContext) IsQueryOptionContext

func (*QueryOptionContext) IsQueryOptionContext()

func (*QueryOptionContext) LOG

func (*QueryOptionContext) NOCACHE

func (s *QueryOptionContext) NOCACHE() antlr.TerminalNode

func (*QueryOptionContext) QUERY

func (*QueryOptionContext) RUN

func (*QueryOptionContext) ToStringTree

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

type QueryOptionsContext

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

func NewEmptyQueryOptionsContext

func NewEmptyQueryOptionsContext() *QueryOptionsContext

func NewQueryOptionsContext

func NewQueryOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *QueryOptionsContext

func (*QueryOptionsContext) Accept

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

func (*QueryOptionsContext) AllCOMMA

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

func (*QueryOptionsContext) AllQueryOption

func (s *QueryOptionsContext) AllQueryOption() []IQueryOptionContext

func (*QueryOptionsContext) COMMA

func (*QueryOptionsContext) EnterRule

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

func (*QueryOptionsContext) ExitRule

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

func (*QueryOptionsContext) GetParser

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

func (*QueryOptionsContext) GetRuleContext

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

func (*QueryOptionsContext) IsQueryOptionsContext

func (*QueryOptionsContext) IsQueryOptionsContext()

func (*QueryOptionsContext) LEFT_ROUND_BRACKET

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

func (*QueryOptionsContext) OPTIONS

func (s *QueryOptionsContext) OPTIONS() antlr.TerminalNode

func (*QueryOptionsContext) QueryOption

func (s *QueryOptionsContext) QueryOption(i int) IQueryOptionContext

func (*QueryOptionsContext) RIGHT_ROUND_BRACKET

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

func (*QueryOptionsContext) ToStringTree

func (s *QueryOptionsContext) 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.

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) 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) 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) 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) 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) QueryOption

func (p *RelationalParser) QueryOption() (localctx IQueryOptionContext)

func (*RelationalParser) QueryOptions

func (p *RelationalParser) QueryOptions() (localctx IQueryOptionsContext)

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) ReturnValue

func (p *RelationalParser) ReturnValue() (localctx IReturnValueContext)

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) SqlReturnStatement

func (p *RelationalParser) SqlReturnStatement() (localctx ISqlReturnStatementContext)

func (*RelationalParser) StartTransaction

func (p *RelationalParser) StartTransaction() (localctx IStartTransactionContext)

func (*RelationalParser) Statement

func (p *RelationalParser) Statement() (localctx IStatementContext)

func (*RelationalParser) Statements

func (p *RelationalParser) Statements() (localctx IStatementsContext)

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) TableFunctionArgs

func (p *RelationalParser) TableFunctionArgs() (localctx ITableFunctionArgsContext)

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) VectorIndexOption

func (p *RelationalParser) VectorIndexOption() (localctx IVectorIndexOptionContext)

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)

	// 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)

	// 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)

	// 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)

	// EnterUserDefinedScalarFunctionStatementBody is called when entering the userDefinedScalarFunctionStatementBody production.
	EnterUserDefinedScalarFunctionStatementBody(c *UserDefinedScalarFunctionStatementBodyContext)

	// EnterExpressionBody is called when entering the expressionBody production.
	EnterExpressionBody(c *ExpressionBodyContext)

	// EnterSqlReturnStatement is called when entering the sqlReturnStatement production.
	EnterSqlReturnStatement(c *SqlReturnStatementContext)

	// EnterReturnValue is called when entering the returnValue production.
	EnterReturnValue(c *ReturnValueContext)

	// 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)

	// EnterTableFunctionArgs is called when entering the tableFunctionArgs production.
	EnterTableFunctionArgs(c *TableFunctionArgsContext)

	// 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)

	// EnterQueryOptions is called when entering the queryOptions production.
	EnterQueryOptions(c *QueryOptionsContext)

	// EnterQueryOption is called when entering the queryOption production.
	EnterQueryOption(c *QueryOptionContext)

	// 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)

	// 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)

	// 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)

	// 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)

	// 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)

	// ExitUserDefinedScalarFunctionStatementBody is called when exiting the userDefinedScalarFunctionStatementBody production.
	ExitUserDefinedScalarFunctionStatementBody(c *UserDefinedScalarFunctionStatementBodyContext)

	// ExitExpressionBody is called when exiting the expressionBody production.
	ExitExpressionBody(c *ExpressionBodyContext)

	// ExitSqlReturnStatement is called when exiting the sqlReturnStatement production.
	ExitSqlReturnStatement(c *SqlReturnStatementContext)

	// ExitReturnValue is called when exiting the returnValue production.
	ExitReturnValue(c *ReturnValueContext)

	// 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)

	// ExitTableFunctionArgs is called when exiting the tableFunctionArgs production.
	ExitTableFunctionArgs(c *TableFunctionArgsContext)

	// 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)

	// ExitQueryOptions is called when exiting the queryOptions production.
	ExitQueryOptions(c *QueryOptionsContext)

	// ExitQueryOption is called when exiting the queryOption production.
	ExitQueryOption(c *QueryOptionContext)

	// 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)

	// 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#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#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#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#userDefinedScalarFunctionStatementBody.
	VisitUserDefinedScalarFunctionStatementBody(ctx *UserDefinedScalarFunctionStatementBodyContext) interface{}

	// Visit a parse tree produced by RelationalParser#expressionBody.
	VisitExpressionBody(ctx *ExpressionBodyContext) interface{}

	// Visit a parse tree produced by RelationalParser#sqlReturnStatement.
	VisitSqlReturnStatement(ctx *SqlReturnStatementContext) interface{}

	// Visit a parse tree produced by RelationalParser#returnValue.
	VisitReturnValue(ctx *ReturnValueContext) 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#tableFunctionArgs.
	VisitTableFunctionArgs(ctx *TableFunctionArgsContext) 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#queryOptions.
	VisitQueryOptions(ctx *QueryOptionsContext) interface{}

	// Visit a parse tree produced by RelationalParser#queryOption.
	VisitQueryOption(ctx *QueryOptionContext) 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#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 ReturnValueContext

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

func NewEmptyReturnValueContext

func NewEmptyReturnValueContext() *ReturnValueContext

func NewReturnValueContext

func NewReturnValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnValueContext

func (*ReturnValueContext) Accept

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

func (*ReturnValueContext) EnterRule

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

func (*ReturnValueContext) ExitRule

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

func (*ReturnValueContext) Expression

func (s *ReturnValueContext) Expression() IExpressionContext

func (*ReturnValueContext) GetParser

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

func (*ReturnValueContext) GetRuleContext

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

func (*ReturnValueContext) IsReturnValueContext

func (*ReturnValueContext) IsReturnValueContext()

func (*ReturnValueContext) ToStringTree

func (s *ReturnValueContext) 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) 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) 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) QueryOptions

func (s *SimpleTableContext) QueryOptions() IQueryOptionsContext

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 SqlReturnStatementContext

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

func NewEmptySqlReturnStatementContext

func NewEmptySqlReturnStatementContext() *SqlReturnStatementContext

func NewSqlReturnStatementContext

func NewSqlReturnStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SqlReturnStatementContext

func (*SqlReturnStatementContext) Accept

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

func (*SqlReturnStatementContext) EnterRule

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

func (*SqlReturnStatementContext) ExitRule

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

func (*SqlReturnStatementContext) GetParser

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

func (*SqlReturnStatementContext) GetRuleContext

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

func (*SqlReturnStatementContext) IsSqlReturnStatementContext

func (*SqlReturnStatementContext) IsSqlReturnStatementContext()

func (*SqlReturnStatementContext) RETURN

func (*SqlReturnStatementContext) ReturnValue

func (*SqlReturnStatementContext) ToStringTree

func (s *SqlReturnStatementContext) 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 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 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 TableFunctionArgsContext

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

func NewEmptyTableFunctionArgsContext

func NewEmptyTableFunctionArgsContext() *TableFunctionArgsContext

func NewTableFunctionArgsContext

func NewTableFunctionArgsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableFunctionArgsContext

func (*TableFunctionArgsContext) Accept

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

func (*TableFunctionArgsContext) AllCOMMA

func (*TableFunctionArgsContext) AllFunctionArg

func (s *TableFunctionArgsContext) AllFunctionArg() []IFunctionArgContext

func (*TableFunctionArgsContext) AllNamedFunctionArg

func (s *TableFunctionArgsContext) AllNamedFunctionArg() []INamedFunctionArgContext

func (*TableFunctionArgsContext) COMMA

func (*TableFunctionArgsContext) EnterRule

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

func (*TableFunctionArgsContext) ExitRule

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

func (*TableFunctionArgsContext) FunctionArg

func (*TableFunctionArgsContext) GetParser

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

func (*TableFunctionArgsContext) GetRuleContext

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

func (*TableFunctionArgsContext) IsTableFunctionArgsContext

func (*TableFunctionArgsContext) IsTableFunctionArgsContext()

func (*TableFunctionArgsContext) NamedFunctionArg

func (s *TableFunctionArgsContext) NamedFunctionArg(i int) INamedFunctionArgContext

func (*TableFunctionArgsContext) ToStringTree

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

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) RIGHT_ROUND_BRACKET

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

func (*TableFunctionContext) TableFunctionArgs

func (s *TableFunctionContext) TableFunctionArgs() ITableFunctionArgsContext

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) 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) QueryOptions

func (s *UpdateStatementContext) QueryOptions() IQueryOptionsContext

func (*UpdateStatementContext) RETURNING

func (s *UpdateStatementContext) RETURNING() antlr.TerminalNode

func (*UpdateStatementContext) SET

func (*UpdateStatementContext) SelectElements

func (s *UpdateStatementContext) SelectElements() ISelectElementsContext

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 UserDefinedScalarFunctionCallContext

type UserDefinedScalarFunctionCallContext struct {
	FunctionCallContext
}

func (*UserDefinedScalarFunctionCallContext) Accept

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

func (*UserDefinedScalarFunctionCallContext) EnterRule

func (*UserDefinedScalarFunctionCallContext) ExitRule

func (*UserDefinedScalarFunctionCallContext) FunctionArgs

func (*UserDefinedScalarFunctionCallContext) GetRuleContext

func (*UserDefinedScalarFunctionCallContext) LEFT_ROUND_BRACKET

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 UserDefinedScalarFunctionStatementBodyContext

type UserDefinedScalarFunctionStatementBodyContext struct {
	RoutineBodyContext
}

func (*UserDefinedScalarFunctionStatementBodyContext) AS

func (*UserDefinedScalarFunctionStatementBodyContext) Accept

func (*UserDefinedScalarFunctionStatementBodyContext) EnterRule

func (*UserDefinedScalarFunctionStatementBodyContext) ExitRule

func (*UserDefinedScalarFunctionStatementBodyContext) FullId

func (*UserDefinedScalarFunctionStatementBodyContext) GetRuleContext

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 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) GetIndexName

func (s *VectorIndexDefinitionContext) GetIndexName() IUidContext

func (*VectorIndexDefinitionContext) GetMethod

func (s *VectorIndexDefinitionContext) GetMethod() antlr.Token

func (*VectorIndexDefinitionContext) GetRuleContext

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

func (*VectorIndexDefinitionContext) GetSource

func (*VectorIndexDefinitionContext) HNSW

func (*VectorIndexDefinitionContext) INDEX

func (*VectorIndexDefinitionContext) IncludeClause

func (*VectorIndexDefinitionContext) IndexColumnList

func (*VectorIndexDefinitionContext) IndexPartitionClause

func (*VectorIndexDefinitionContext) ON

func (*VectorIndexDefinitionContext) SPFRESH

func (*VectorIndexDefinitionContext) SetIndexName

func (s *VectorIndexDefinitionContext) SetIndexName(v IUidContext)

func (*VectorIndexDefinitionContext) SetMethod

func (s *VectorIndexDefinitionContext) SetMethod(v antlr.Token)

func (*VectorIndexDefinitionContext) SetSource

func (*VectorIndexDefinitionContext) USING

func (*VectorIndexDefinitionContext) Uid

func (*VectorIndexDefinitionContext) VECTOR

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) BooleanLiteral

func (*VectorIndexOptionContext) CONNECTIVITY

func (s *VectorIndexOptionContext) CONNECTIVITY() antlr.TerminalNode

func (*VectorIndexOptionContext) DECIMAL_LITERAL

func (s *VectorIndexOptionContext) DECIMAL_LITERAL() antlr.TerminalNode

func (*VectorIndexOptionContext) EF_CONSTRUCTION

func (s *VectorIndexOptionContext) EF_CONSTRUCTION() antlr.TerminalNode

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) GetConnectivity

func (s *VectorIndexOptionContext) GetConnectivity() antlr.Token

func (*VectorIndexOptionContext) GetEfConstruction

func (s *VectorIndexOptionContext) GetEfConstruction() antlr.Token

func (*VectorIndexOptionContext) GetMMax

func (s *VectorIndexOptionContext) GetMMax() antlr.Token

func (*VectorIndexOptionContext) GetMMaxZero

func (s *VectorIndexOptionContext) GetMMaxZero() antlr.Token

func (*VectorIndexOptionContext) GetMaintainStatsProbability

func (s *VectorIndexOptionContext) GetMaintainStatsProbability() antlr.Token

func (*VectorIndexOptionContext) GetMetric

func (*VectorIndexOptionContext) GetParser

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

func (*VectorIndexOptionContext) GetRabitQNumExBits

func (s *VectorIndexOptionContext) GetRabitQNumExBits() antlr.Token

func (*VectorIndexOptionContext) GetRuleContext

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

func (*VectorIndexOptionContext) GetStatsProbability

func (s *VectorIndexOptionContext) GetStatsProbability() antlr.Token

func (*VectorIndexOptionContext) GetStatsThreshold

func (s *VectorIndexOptionContext) GetStatsThreshold() antlr.Token

func (*VectorIndexOptionContext) GetUseRabitQ

func (*VectorIndexOptionContext) HnswMetric

func (*VectorIndexOptionContext) IsVectorIndexOptionContext

func (*VectorIndexOptionContext) IsVectorIndexOptionContext()

func (*VectorIndexOptionContext) MAINTAIN_STATS_PROBABILITY

func (s *VectorIndexOptionContext) MAINTAIN_STATS_PROBABILITY() antlr.TerminalNode

func (*VectorIndexOptionContext) METRIC

func (*VectorIndexOptionContext) M_MAX

func (*VectorIndexOptionContext) M_MAX_0

func (*VectorIndexOptionContext) RABITQ_NUM_EX_BITS

func (s *VectorIndexOptionContext) RABITQ_NUM_EX_BITS() antlr.TerminalNode

func (*VectorIndexOptionContext) REAL_LITERAL

func (s *VectorIndexOptionContext) REAL_LITERAL() antlr.TerminalNode

func (*VectorIndexOptionContext) SAMPLE_VECTOR_STATS_PROBABILITY

func (s *VectorIndexOptionContext) SAMPLE_VECTOR_STATS_PROBABILITY() antlr.TerminalNode

func (*VectorIndexOptionContext) STATS_THRESHOLD

func (s *VectorIndexOptionContext) STATS_THRESHOLD() antlr.TerminalNode

func (*VectorIndexOptionContext) SetConnectivity

func (s *VectorIndexOptionContext) SetConnectivity(v antlr.Token)

func (*VectorIndexOptionContext) SetEfConstruction

func (s *VectorIndexOptionContext) SetEfConstruction(v antlr.Token)

func (*VectorIndexOptionContext) SetMMax

func (s *VectorIndexOptionContext) SetMMax(v antlr.Token)

func (*VectorIndexOptionContext) SetMMaxZero

func (s *VectorIndexOptionContext) SetMMaxZero(v antlr.Token)

func (*VectorIndexOptionContext) SetMaintainStatsProbability

func (s *VectorIndexOptionContext) SetMaintainStatsProbability(v antlr.Token)

func (*VectorIndexOptionContext) SetMetric

func (*VectorIndexOptionContext) SetRabitQNumExBits

func (s *VectorIndexOptionContext) SetRabitQNumExBits(v antlr.Token)

func (*VectorIndexOptionContext) SetStatsProbability

func (s *VectorIndexOptionContext) SetStatsProbability(v antlr.Token)

func (*VectorIndexOptionContext) SetStatsThreshold

func (s *VectorIndexOptionContext) SetStatsThreshold(v antlr.Token)

func (*VectorIndexOptionContext) SetUseRabitQ

func (*VectorIndexOptionContext) ToStringTree

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

func (*VectorIndexOptionContext) USE_RABITQ

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