tsql

package
v0.0.0-...-4c43aeb Latest Latest
Warning

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

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

Documentation

Index

Constants

View Source
const (
	TSqlLexerABSENT                                      = 1
	TSqlLexerADD                                         = 2
	TSqlLexerAES                                         = 3
	TSqlLexerALL                                         = 4
	TSqlLexerALLOW_CONNECTIONS                           = 5
	TSqlLexerALLOW_MULTIPLE_EVENT_LOSS                   = 6
	TSqlLexerALLOW_SINGLE_EVENT_LOSS                     = 7
	TSqlLexerALTER                                       = 8
	TSqlLexerAND                                         = 9
	TSqlLexerANONYMOUS                                   = 10
	TSqlLexerANY                                         = 11
	TSqlLexerAPPEND                                      = 12
	TSqlLexerAPPLICATION                                 = 13
	TSqlLexerAS                                          = 14
	TSqlLexerASC                                         = 15
	TSqlLexerASYMMETRIC                                  = 16
	TSqlLexerASYNCHRONOUS_COMMIT                         = 17
	TSqlLexerAUTHORIZATION                               = 18
	TSqlLexerAUTHENTICATION                              = 19
	TSqlLexerAUTOMATED_BACKUP_PREFERENCE                 = 20
	TSqlLexerAUTOMATIC                                   = 21
	TSqlLexerAVAILABILITY_MODE                           = 22
	TSqlLexerBACKSLASH                                   = 23
	TSqlLexerBACKUP                                      = 24
	TSqlLexerBEFORE                                      = 25
	TSqlLexerBEGIN                                       = 26
	TSqlLexerBETWEEN                                     = 27
	TSqlLexerBLOCK                                       = 28
	TSqlLexerBLOCKSIZE                                   = 29
	TSqlLexerBLOCKING_HIERARCHY                          = 30
	TSqlLexerBREAK                                       = 31
	TSqlLexerBROWSE                                      = 32
	TSqlLexerBUFFER                                      = 33
	TSqlLexerBUFFERCOUNT                                 = 34
	TSqlLexerBULK                                        = 35
	TSqlLexerBY                                          = 36
	TSqlLexerCACHE                                       = 37
	TSqlLexerCALLED                                      = 38
	TSqlLexerCASCADE                                     = 39
	TSqlLexerCASE                                        = 40
	TSqlLexerCERTIFICATE                                 = 41
	TSqlLexerCHANGETABLE                                 = 42
	TSqlLexerCHANGES                                     = 43
	TSqlLexerCHECK                                       = 44
	TSqlLexerCHECKPOINT                                  = 45
	TSqlLexerCHECK_POLICY                                = 46
	TSqlLexerCHECK_EXPIRATION                            = 47
	TSqlLexerCLASSIFIER_FUNCTION                         = 48
	TSqlLexerCLOSE                                       = 49
	TSqlLexerCLUSTER                                     = 50
	TSqlLexerCLUSTERED                                   = 51
	TSqlLexerCOALESCE                                    = 52
	TSqlLexerCOLLATE                                     = 53
	TSqlLexerCOLUMN                                      = 54
	TSqlLexerCOMPRESSION                                 = 55
	TSqlLexerCOMMIT                                      = 56
	TSqlLexerCOMPUTE                                     = 57
	TSqlLexerCONFIGURATION                               = 58
	TSqlLexerCONSTRAINT                                  = 59
	TSqlLexerCONTAINMENT                                 = 60
	TSqlLexerCONTAINS                                    = 61
	TSqlLexerCONTAINSTABLE                               = 62
	TSqlLexerCONTEXT                                     = 63
	TSqlLexerCONTINUE                                    = 64
	TSqlLexerCONTINUE_AFTER_ERROR                        = 65
	TSqlLexerCONTRACT                                    = 66
	TSqlLexerCONTRACT_NAME                               = 67
	TSqlLexerCONVERSATION                                = 68
	TSqlLexerCONVERT                                     = 69
	TSqlLexerCOPY_ONLY                                   = 70
	TSqlLexerCREATE                                      = 71
	TSqlLexerCROSS                                       = 72
	TSqlLexerCURRENT                                     = 73
	TSqlLexerCURRENT_DATE                                = 74
	TSqlLexerCURRENT_TIME                                = 75
	TSqlLexerCURRENT_TIMESTAMP                           = 76
	TSqlLexerCURRENT_USER                                = 77
	TSqlLexerCURSOR                                      = 78
	TSqlLexerCYCLE                                       = 79
	TSqlLexerDATA                                        = 80
	TSqlLexerDATA_COMPRESSION                            = 81
	TSqlLexerDATA_SOURCE                                 = 82
	TSqlLexerDATABASE                                    = 83
	TSqlLexerDATABASE_MIRRORING                          = 84
	TSqlLexerDBCC                                        = 85
	TSqlLexerDEALLOCATE                                  = 86
	TSqlLexerDECLARE                                     = 87
	TSqlLexerDEFAULT                                     = 88
	TSqlLexerDEFAULT_DATABASE                            = 89
	TSqlLexerDEFAULT_SCHEMA                              = 90
	TSqlLexerDELETE                                      = 91
	TSqlLexerDENY                                        = 92
	TSqlLexerDESC                                        = 93
	TSqlLexerDIAGNOSTICS                                 = 94
	TSqlLexerDIFFERENTIAL                                = 95
	TSqlLexerDISK                                        = 96
	TSqlLexerDISTINCT                                    = 97
	TSqlLexerDISTRIBUTED                                 = 98
	TSqlLexerDOUBLE                                      = 99
	TSqlLexerDOUBLE_BACK_SLASH                           = 100
	TSqlLexerDOUBLE_FORWARD_SLASH                        = 101
	TSqlLexerDROP                                        = 102
	TSqlLexerDTC_SUPPORT                                 = 103
	TSqlLexerDUMP                                        = 104
	TSqlLexerELSE                                        = 105
	TSqlLexerENABLED                                     = 106
	TSqlLexerEND                                         = 107
	TSqlLexerENDPOINT                                    = 108
	TSqlLexerERRLVL                                      = 109
	TSqlLexerESCAPE                                      = 110
	TSqlLexerERROR                                       = 111
	TSqlLexerEVENT                                       = 112
	TSqlLexerEVENTDATA                                   = 113
	TSqlLexerEVENT_RETENTION_MODE                        = 114
	TSqlLexerEXCEPT                                      = 115
	TSqlLexerEXECUTABLE_FILE                             = 116
	TSqlLexerEXECUTE                                     = 117
	TSqlLexerEXISTS                                      = 118
	TSqlLexerEXPIREDATE                                  = 119
	TSqlLexerEXIT                                        = 120
	TSqlLexerEXTENSION                                   = 121
	TSqlLexerEXTERNAL                                    = 122
	TSqlLexerEXTERNAL_ACCESS                             = 123
	TSqlLexerFAILOVER                                    = 124
	TSqlLexerFAILURECONDITIONLEVEL                       = 125
	TSqlLexerFAN_IN                                      = 126
	TSqlLexerFETCH                                       = 127
	TSqlLexerFILE                                        = 128
	TSqlLexerFILENAME                                    = 129
	TSqlLexerFILLFACTOR                                  = 130
	TSqlLexerFILE_SNAPSHOT                               = 131
	TSqlLexerFOR                                         = 132
	TSqlLexerFORCESEEK                                   = 133
	TSqlLexerFORCE_SERVICE_ALLOW_DATA_LOSS               = 134
	TSqlLexerFOREIGN                                     = 135
	TSqlLexerFREETEXT                                    = 136
	TSqlLexerFREETEXTTABLE                               = 137
	TSqlLexerFROM                                        = 138
	TSqlLexerFULL                                        = 139
	TSqlLexerFUNCTION                                    = 140
	TSqlLexerGET                                         = 141
	TSqlLexerGOTO                                        = 142
	TSqlLexerGOVERNOR                                    = 143
	TSqlLexerGRANT                                       = 144
	TSqlLexerGROUP                                       = 145
	TSqlLexerHAVING                                      = 146
	TSqlLexerHASHED                                      = 147
	TSqlLexerHEALTHCHECKTIMEOUT                          = 148
	TSqlLexerIDENTITY                                    = 149
	TSqlLexerIDENTITYCOL                                 = 150
	TSqlLexerIDENTITY_INSERT                             = 151
	TSqlLexerIF                                          = 152
	TSqlLexerIIF                                         = 153
	TSqlLexerIN                                          = 154
	TSqlLexerINCLUDE                                     = 155
	TSqlLexerINCREMENT                                   = 156
	TSqlLexerINDEX                                       = 157
	TSqlLexerINFINITE                                    = 158
	TSqlLexerINIT                                        = 159
	TSqlLexerINNER                                       = 160
	TSqlLexerINSERT                                      = 161
	TSqlLexerINSTEAD                                     = 162
	TSqlLexerINTERSECT                                   = 163
	TSqlLexerINTO                                        = 164
	TSqlLexerIPV4_ADDR                                   = 165
	TSqlLexerIPV6_ADDR                                   = 166
	TSqlLexerIS                                          = 167
	TSqlLexerISNULL                                      = 168
	TSqlLexerJOIN                                        = 169
	TSqlLexerKERBEROS                                    = 170
	TSqlLexerKEY                                         = 171
	TSqlLexerKEY_PATH                                    = 172
	TSqlLexerKEY_STORE_PROVIDER_NAME                     = 173
	TSqlLexerKILL                                        = 174
	TSqlLexerLANGUAGE                                    = 175
	TSqlLexerLEFT                                        = 176
	TSqlLexerLIBRARY                                     = 177
	TSqlLexerLIFETIME                                    = 178
	TSqlLexerLIKE                                        = 179
	TSqlLexerLINENO                                      = 180
	TSqlLexerLINUX                                       = 181
	TSqlLexerLISTENER_IP                                 = 182
	TSqlLexerLISTENER_PORT                               = 183
	TSqlLexerLOAD                                        = 184
	TSqlLexerLOCAL_SERVICE_NAME                          = 185
	TSqlLexerLOG                                         = 186
	TSqlLexerMATCHED                                     = 187
	TSqlLexerMASTER                                      = 188
	TSqlLexerMAX_MEMORY                                  = 189
	TSqlLexerMAXTRANSFER                                 = 190
	TSqlLexerMAXVALUE                                    = 191
	TSqlLexerMAX_DISPATCH_LATENCY                        = 192
	TSqlLexerMAX_EVENT_SIZE                              = 193
	TSqlLexerMAX_SIZE                                    = 194
	TSqlLexerMAX_OUTSTANDING_IO_PER_VOLUME               = 195
	TSqlLexerMEDIADESCRIPTION                            = 196
	TSqlLexerMEDIANAME                                   = 197
	TSqlLexerMEMBER                                      = 198
	TSqlLexerMEMORY_PARTITION_MODE                       = 199
	TSqlLexerMERGE                                       = 200
	TSqlLexerMESSAGE_FORWARDING                          = 201
	TSqlLexerMESSAGE_FORWARD_SIZE                        = 202
	TSqlLexerMINVALUE                                    = 203
	TSqlLexerMIRROR                                      = 204
	TSqlLexerMUST_CHANGE                                 = 205
	TSqlLexerNATIONAL                                    = 206
	TSqlLexerNEGOTIATE                                   = 207
	TSqlLexerNOCHECK                                     = 208
	TSqlLexerNOFORMAT                                    = 209
	TSqlLexerNOINIT                                      = 210
	TSqlLexerNONCLUSTERED                                = 211
	TSqlLexerNONE                                        = 212
	TSqlLexerNOREWIND                                    = 213
	TSqlLexerNOSKIP                                      = 214
	TSqlLexerNOUNLOAD                                    = 215
	TSqlLexerNO_CHECKSUM                                 = 216
	TSqlLexerNO_COMPRESSION                              = 217
	TSqlLexerNO_EVENT_LOSS                               = 218
	TSqlLexerNOT                                         = 219
	TSqlLexerNOTIFICATION                                = 220
	TSqlLexerNTLM                                        = 221
	TSqlLexerNULL                                        = 222
	TSqlLexerNULLIF                                      = 223
	TSqlLexerOF                                          = 224
	TSqlLexerOFF                                         = 225
	TSqlLexerOFFSETS                                     = 226
	TSqlLexerOLD_PASSWORD                                = 227
	TSqlLexerON                                          = 228
	TSqlLexerON_FAILURE                                  = 229
	TSqlLexerOPEN                                        = 230
	TSqlLexerOPENDATASOURCE                              = 231
	TSqlLexerOPENQUERY                                   = 232
	TSqlLexerOPENROWSET                                  = 233
	TSqlLexerOPENXML                                     = 234
	TSqlLexerOPTION                                      = 235
	TSqlLexerOR                                          = 236
	TSqlLexerORDER                                       = 237
	TSqlLexerOUTER                                       = 238
	TSqlLexerOVER                                        = 239
	TSqlLexerPAGE                                        = 240
	TSqlLexerPARAM_NODE                                  = 241
	TSqlLexerPARTIAL                                     = 242
	TSqlLexerPASSWORD                                    = 243
	TSqlLexerPERCENT                                     = 244
	TSqlLexerPERMISSION_SET                              = 245
	TSqlLexerPER_CPU                                     = 246
	TSqlLexerPER_DB                                      = 247
	TSqlLexerPER_NODE                                    = 248
	TSqlLexerPIVOT                                       = 249
	TSqlLexerPLAN                                        = 250
	TSqlLexerPLATFORM                                    = 251
	TSqlLexerPOLICY                                      = 252
	TSqlLexerPRECISION                                   = 253
	TSqlLexerPREDICATE                                   = 254
	TSqlLexerPRIMARY                                     = 255
	TSqlLexerPRINT                                       = 256
	TSqlLexerPROC                                        = 257
	TSqlLexerPROCEDURE                                   = 258
	TSqlLexerPROCESS                                     = 259
	TSqlLexerPUBLIC                                      = 260
	TSqlLexerPYTHON                                      = 261
	TSqlLexerR                                           = 262
	TSqlLexerRAISERROR                                   = 263
	TSqlLexerRAW                                         = 264
	TSqlLexerREAD                                        = 265
	TSqlLexerREADTEXT                                    = 266
	TSqlLexerREAD_WRITE_FILEGROUPS                       = 267
	TSqlLexerRECONFIGURE                                 = 268
	TSqlLexerREFERENCES                                  = 269
	TSqlLexerREGENERATE                                  = 270
	TSqlLexerRELATED_CONVERSATION                        = 271
	TSqlLexerRELATED_CONVERSATION_GROUP                  = 272
	TSqlLexerREPLICATION                                 = 273
	TSqlLexerREQUIRED                                    = 274
	TSqlLexerRESET                                       = 275
	TSqlLexerRESTART                                     = 276
	TSqlLexerRESTORE                                     = 277
	TSqlLexerRESTRICT                                    = 278
	TSqlLexerRESUME                                      = 279
	TSqlLexerRETAINDAYS                                  = 280
	TSqlLexerRETURN                                      = 281
	TSqlLexerRETURNS                                     = 282
	TSqlLexerREVERT                                      = 283
	TSqlLexerREVOKE                                      = 284
	TSqlLexerREWIND                                      = 285
	TSqlLexerRIGHT                                       = 286
	TSqlLexerROLLBACK                                    = 287
	TSqlLexerROLE                                        = 288
	TSqlLexerROWCOUNT                                    = 289
	TSqlLexerROWGUIDCOL                                  = 290
	TSqlLexerRSA_512                                     = 291
	TSqlLexerRSA_1024                                    = 292
	TSqlLexerRSA_2048                                    = 293
	TSqlLexerRSA_3072                                    = 294
	TSqlLexerRSA_4096                                    = 295
	TSqlLexerSAFETY                                      = 296
	TSqlLexerRULE                                        = 297
	TSqlLexerSAFE                                        = 298
	TSqlLexerSAVE                                        = 299
	TSqlLexerSCHEDULER                                   = 300
	TSqlLexerSCHEMA                                      = 301
	TSqlLexerSCHEME                                      = 302
	TSqlLexerSECURITY                                    = 303
	TSqlLexerSECURITYAUDIT                               = 304
	TSqlLexerSELECT                                      = 305
	TSqlLexerSEMANTICKEYPHRASETABLE                      = 306
	TSqlLexerSEMANTICSIMILARITYDETAILSTABLE              = 307
	TSqlLexerSEMANTICSIMILARITYTABLE                     = 308
	TSqlLexerSEQUENCE                                    = 309
	TSqlLexerSERVER                                      = 310
	TSqlLexerSERVICE                                     = 311
	TSqlLexerSERVICE_BROKER                              = 312
	TSqlLexerSERVICE_NAME                                = 313
	TSqlLexerSESSION                                     = 314
	TSqlLexerSESSION_USER                                = 315
	TSqlLexerSET                                         = 316
	TSqlLexerSETUSER                                     = 317
	TSqlLexerSHUTDOWN                                    = 318
	TSqlLexerSID                                         = 319
	TSqlLexerSKIP_KEYWORD                                = 320
	TSqlLexerSOFTNUMA                                    = 321
	TSqlLexerSOME                                        = 322
	TSqlLexerSOURCE                                      = 323
	TSqlLexerSPECIFICATION                               = 324
	TSqlLexerSPLIT                                       = 325
	TSqlLexerSQLDUMPERFLAGS                              = 326
	TSqlLexerSQLDUMPERPATH                               = 327
	TSqlLexerSQLDUMPERTIMEOUT                            = 328
	TSqlLexerSTATISTICS                                  = 329
	TSqlLexerSTATE                                       = 330
	TSqlLexerSTATS                                       = 331
	TSqlLexerSTART                                       = 332
	TSqlLexerSTARTED                                     = 333
	TSqlLexerSTARTUP_STATE                               = 334
	TSqlLexerSTOP                                        = 335
	TSqlLexerSTOPPED                                     = 336
	TSqlLexerSTOP_ON_ERROR                               = 337
	TSqlLexerSUPPORTED                                   = 338
	TSqlLexerSYSTEM                                      = 339
	TSqlLexerSYSTEM_USER                                 = 340
	TSqlLexerTABLE                                       = 341
	TSqlLexerTABLESAMPLE                                 = 342
	TSqlLexerTAPE                                        = 343
	TSqlLexerTARGET                                      = 344
	TSqlLexerTCP                                         = 345
	TSqlLexerTEXTSIZE                                    = 346
	TSqlLexerTHEN                                        = 347
	TSqlLexerTO                                          = 348
	TSqlLexerTOP                                         = 349
	TSqlLexerTRACK_CAUSALITY                             = 350
	TSqlLexerTRAN                                        = 351
	TSqlLexerTRANSACTION                                 = 352
	TSqlLexerTRANSFER                                    = 353
	TSqlLexerTRIGGER                                     = 354
	TSqlLexerTRUNCATE                                    = 355
	TSqlLexerTSEQUAL                                     = 356
	TSqlLexerUNCHECKED                                   = 357
	TSqlLexerUNION                                       = 358
	TSqlLexerUNIQUE                                      = 359
	TSqlLexerUNLOCK                                      = 360
	TSqlLexerUNPIVOT                                     = 361
	TSqlLexerUNSAFE                                      = 362
	TSqlLexerUPDATE                                      = 363
	TSqlLexerUPDATETEXT                                  = 364
	TSqlLexerURL                                         = 365
	TSqlLexerUSE                                         = 366
	TSqlLexerUSED                                        = 367
	TSqlLexerUSER                                        = 368
	TSqlLexerVALUES                                      = 369
	TSqlLexerVARYING                                     = 370
	TSqlLexerVERBOSELOGGING                              = 371
	TSqlLexerVIEW                                        = 372
	TSqlLexerVISIBILITY                                  = 373
	TSqlLexerWAITFOR                                     = 374
	TSqlLexerWHEN                                        = 375
	TSqlLexerWHERE                                       = 376
	TSqlLexerWHILE                                       = 377
	TSqlLexerWINDOWS                                     = 378
	TSqlLexerWITH                                        = 379
	TSqlLexerWITHIN                                      = 380
	TSqlLexerWITHOUT                                     = 381
	TSqlLexerWITNESS                                     = 382
	TSqlLexerWRITETEXT                                   = 383
	TSqlLexerABSOLUTE                                    = 384
	TSqlLexerACCENT_SENSITIVITY                          = 385
	TSqlLexerACTION                                      = 386
	TSqlLexerACTIVATION                                  = 387
	TSqlLexerACTIVE                                      = 388
	TSqlLexerADDRESS                                     = 389
	TSqlLexerAES_128                                     = 390
	TSqlLexerAES_192                                     = 391
	TSqlLexerAES_256                                     = 392
	TSqlLexerAFFINITY                                    = 393
	TSqlLexerAFTER                                       = 394
	TSqlLexerAGGREGATE                                   = 395
	TSqlLexerALGORITHM                                   = 396
	TSqlLexerALLOW_ENCRYPTED_VALUE_MODIFICATIONS         = 397
	TSqlLexerALLOW_SNAPSHOT_ISOLATION                    = 398
	TSqlLexerALLOWED                                     = 399
	TSqlLexerANSI_NULL_DEFAULT                           = 400
	TSqlLexerANSI_NULLS                                  = 401
	TSqlLexerANSI_PADDING                                = 402
	TSqlLexerANSI_WARNINGS                               = 403
	TSqlLexerAPPLICATION_LOG                             = 404
	TSqlLexerAPPLY                                       = 405
	TSqlLexerARITHABORT                                  = 406
	TSqlLexerASSEMBLY                                    = 407
	TSqlLexerAUDIT                                       = 408
	TSqlLexerAUDIT_GUID                                  = 409
	TSqlLexerAUTO                                        = 410
	TSqlLexerAUTO_CLEANUP                                = 411
	TSqlLexerAUTO_CLOSE                                  = 412
	TSqlLexerAUTO_CREATE_STATISTICS                      = 413
	TSqlLexerAUTO_SHRINK                                 = 414
	TSqlLexerAUTO_UPDATE_STATISTICS                      = 415
	TSqlLexerAUTO_UPDATE_STATISTICS_ASYNC                = 416
	TSqlLexerAVAILABILITY                                = 417
	TSqlLexerAVG                                         = 418
	TSqlLexerBACKUP_PRIORITY                             = 419
	TSqlLexerBEGIN_DIALOG                                = 420
	TSqlLexerBIGINT                                      = 421
	TSqlLexerBINARY_BASE64                               = 422
	TSqlLexerBINARY_CHECKSUM                             = 423
	TSqlLexerBINDING                                     = 424
	TSqlLexerBLOB_STORAGE                                = 425
	TSqlLexerBROKER                                      = 426
	TSqlLexerBROKER_INSTANCE                             = 427
	TSqlLexerBULK_LOGGED                                 = 428
	TSqlLexerCALLER                                      = 429
	TSqlLexerCAP_CPU_PERCENT                             = 430
	TSqlLexerCAST                                        = 431
	TSqlLexerCATALOG                                     = 432
	TSqlLexerCATCH                                       = 433
	TSqlLexerCHANGE_RETENTION                            = 434
	TSqlLexerCHANGE_TRACKING                             = 435
	TSqlLexerCHECKSUM                                    = 436
	TSqlLexerCHECKSUM_AGG                                = 437
	TSqlLexerCLEANUP                                     = 438
	TSqlLexerCOLLECTION                                  = 439
	TSqlLexerCOLUMN_MASTER_KEY                           = 440
	TSqlLexerCOMMITTED                                   = 441
	TSqlLexerCOMPATIBILITY_LEVEL                         = 442
	TSqlLexerCONCAT                                      = 443
	TSqlLexerCONCAT_NULL_YIELDS_NULL                     = 444
	TSqlLexerCONTENT                                     = 445
	TSqlLexerCONTROL                                     = 446
	TSqlLexerCOOKIE                                      = 447
	TSqlLexerCOUNT                                       = 448
	TSqlLexerCOUNT_BIG                                   = 449
	TSqlLexerCOUNTER                                     = 450
	TSqlLexerCPU                                         = 451
	TSqlLexerCREATE_NEW                                  = 452
	TSqlLexerCREATION_DISPOSITION                        = 453
	TSqlLexerCREDENTIAL                                  = 454
	TSqlLexerCRYPTOGRAPHIC                               = 455
	TSqlLexerCURSOR_CLOSE_ON_COMMIT                      = 456
	TSqlLexerCURSOR_DEFAULT                              = 457
	TSqlLexerDATE_CORRELATION_OPTIMIZATION               = 458
	TSqlLexerDATEADD                                     = 459
	TSqlLexerDATEDIFF                                    = 460
	TSqlLexerDATENAME                                    = 461
	TSqlLexerDATEPART                                    = 462
	TSqlLexerDAYS                                        = 463
	TSqlLexerDB_CHAINING                                 = 464
	TSqlLexerDB_FAILOVER                                 = 465
	TSqlLexerDECRYPTION                                  = 466
	TSqlLexerDEFAULT_DOUBLE_QUOTE                        = 467
	TSqlLexerDEFAULT_FULLTEXT_LANGUAGE                   = 468
	TSqlLexerDEFAULT_LANGUAGE                            = 469
	TSqlLexerDELAY                                       = 470
	TSqlLexerDELAYED_DURABILITY                          = 471
	TSqlLexerDELETED                                     = 472
	TSqlLexerDENSE_RANK                                  = 473
	TSqlLexerDEPENDENTS                                  = 474
	TSqlLexerDES                                         = 475
	TSqlLexerDESCRIPTION                                 = 476
	TSqlLexerDESX                                        = 477
	TSqlLexerDHCP                                        = 478
	TSqlLexerDIALOG                                      = 479
	TSqlLexerDIRECTORY_NAME                              = 480
	TSqlLexerDISABLE                                     = 481
	TSqlLexerDISABLE_BROKER                              = 482
	TSqlLexerDISABLED                                    = 483
	TSqlLexerDISK_DRIVE                                  = 484
	TSqlLexerDOCUMENT                                    = 485
	TSqlLexerDYNAMIC                                     = 486
	TSqlLexerELEMENTS                                    = 487
	TSqlLexerEMERGENCY                                   = 488
	TSqlLexerEMPTY                                       = 489
	TSqlLexerENABLE                                      = 490
	TSqlLexerENABLE_BROKER                               = 491
	TSqlLexerENCRYPTED_VALUE                             = 492
	TSqlLexerENCRYPTION                                  = 493
	TSqlLexerENDPOINT_URL                                = 494
	TSqlLexerERROR_BROKER_CONVERSATIONS                  = 495
	TSqlLexerEXCLUSIVE                                   = 496
	TSqlLexerEXECUTABLE                                  = 497
	TSqlLexerEXIST                                       = 498
	TSqlLexerEXPAND                                      = 499
	TSqlLexerEXPIRY_DATE                                 = 500
	TSqlLexerEXPLICIT                                    = 501
	TSqlLexerFAIL_OPERATION                              = 502
	TSqlLexerFAILOVER_MODE                               = 503
	TSqlLexerFAILURE                                     = 504
	TSqlLexerFAILURE_CONDITION_LEVEL                     = 505
	TSqlLexerFAST                                        = 506
	TSqlLexerFAST_FORWARD                                = 507
	TSqlLexerFILEGROUP                                   = 508
	TSqlLexerFILEGROWTH                                  = 509
	TSqlLexerFILEPATH                                    = 510
	TSqlLexerFILESTREAM                                  = 511
	TSqlLexerFILTER                                      = 512
	TSqlLexerFIRST                                       = 513
	TSqlLexerFIRST_VALUE                                 = 514
	TSqlLexerFOLLOWING                                   = 515
	TSqlLexerFORCE                                       = 516
	TSqlLexerFORCE_FAILOVER_ALLOW_DATA_LOSS              = 517
	TSqlLexerFORCED                                      = 518
	TSqlLexerFORMAT                                      = 519
	TSqlLexerFORWARD_ONLY                                = 520
	TSqlLexerFULLSCAN                                    = 521
	TSqlLexerFULLTEXT                                    = 522
	TSqlLexerGB                                          = 523
	TSqlLexerGETDATE                                     = 524
	TSqlLexerGETUTCDATE                                  = 525
	TSqlLexerGLOBAL                                      = 526
	TSqlLexerGO                                          = 527
	TSqlLexerGROUP_MAX_REQUESTS                          = 528
	TSqlLexerGROUPING                                    = 529
	TSqlLexerGROUPING_ID                                 = 530
	TSqlLexerHADR                                        = 531
	TSqlLexerHASH                                        = 532
	TSqlLexerHEALTH_CHECK_TIMEOUT                        = 533
	TSqlLexerHIGH                                        = 534
	TSqlLexerHONOR_BROKER_PRIORITY                       = 535
	TSqlLexerHOURS                                       = 536
	TSqlLexerIDENTITY_VALUE                              = 537
	TSqlLexerIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX       = 538
	TSqlLexerIMMEDIATE                                   = 539
	TSqlLexerIMPERSONATE                                 = 540
	TSqlLexerIMPORTANCE                                  = 541
	TSqlLexerINCLUDE_NULL_VALUES                         = 542
	TSqlLexerINCREMENTAL                                 = 543
	TSqlLexerINITIATOR                                   = 544
	TSqlLexerINPUT                                       = 545
	TSqlLexerINSENSITIVE                                 = 546
	TSqlLexerINSERTED                                    = 547
	TSqlLexerINT                                         = 548
	TSqlLexerIP                                          = 549
	TSqlLexerISOLATION                                   = 550
	TSqlLexerJSON                                        = 551
	TSqlLexerKB                                          = 552
	TSqlLexerKEEP                                        = 553
	TSqlLexerKEEPFIXED                                   = 554
	TSqlLexerKEY_SOURCE                                  = 555
	TSqlLexerKEYS                                        = 556
	TSqlLexerKEYSET                                      = 557
	TSqlLexerLAG                                         = 558
	TSqlLexerLAST                                        = 559
	TSqlLexerLAST_VALUE                                  = 560
	TSqlLexerLEAD                                        = 561
	TSqlLexerLEVEL                                       = 562
	TSqlLexerLIST                                        = 563
	TSqlLexerLISTENER                                    = 564
	TSqlLexerLISTENER_URL                                = 565
	TSqlLexerLOB_COMPACTION                              = 566
	TSqlLexerLOCAL                                       = 567
	TSqlLexerLOCATION                                    = 568
	TSqlLexerLOCK                                        = 569
	TSqlLexerLOCK_ESCALATION                             = 570
	TSqlLexerLOGIN                                       = 571
	TSqlLexerLOOP                                        = 572
	TSqlLexerLOW                                         = 573
	TSqlLexerMANUAL                                      = 574
	TSqlLexerMARK                                        = 575
	TSqlLexerMATERIALIZED                                = 576
	TSqlLexerMAX                                         = 577
	TSqlLexerMAX_CPU_PERCENT                             = 578
	TSqlLexerMAX_DOP                                     = 579
	TSqlLexerMAX_FILES                                   = 580
	TSqlLexerMAX_IOPS_PER_VOLUME                         = 581
	TSqlLexerMAX_MEMORY_PERCENT                          = 582
	TSqlLexerMAX_PROCESSES                               = 583
	TSqlLexerMAX_QUEUE_READERS                           = 584
	TSqlLexerMAX_ROLLOVER_FILES                          = 585
	TSqlLexerMAXDOP                                      = 586
	TSqlLexerMAXRECURSION                                = 587
	TSqlLexerMAXSIZE                                     = 588
	TSqlLexerMB                                          = 589
	TSqlLexerMEDIUM                                      = 590
	TSqlLexerMEMORY_OPTIMIZED_DATA                       = 591
	TSqlLexerMESSAGE                                     = 592
	TSqlLexerMIN                                         = 593
	TSqlLexerMIN_ACTIVE_ROWVERSION                       = 594
	TSqlLexerMIN_CPU_PERCENT                             = 595
	TSqlLexerMIN_IOPS_PER_VOLUME                         = 596
	TSqlLexerMIN_MEMORY_PERCENT                          = 597
	TSqlLexerMINUTES                                     = 598
	TSqlLexerMIRROR_ADDRESS                              = 599
	TSqlLexerMIXED_PAGE_ALLOCATION                       = 600
	TSqlLexerMODE                                        = 601
	TSqlLexerMODIFY                                      = 602
	TSqlLexerMOVE                                        = 603
	TSqlLexerMULTI_USER                                  = 604
	TSqlLexerNAME                                        = 605
	TSqlLexerNESTED_TRIGGERS                             = 606
	TSqlLexerNEW_ACCOUNT                                 = 607
	TSqlLexerNEW_BROKER                                  = 608
	TSqlLexerNEW_PASSWORD                                = 609
	TSqlLexerNEXT                                        = 610
	TSqlLexerNO                                          = 611
	TSqlLexerNO_TRUNCATE                                 = 612
	TSqlLexerNO_WAIT                                     = 613
	TSqlLexerNOCOUNT                                     = 614
	TSqlLexerNODES                                       = 615
	TSqlLexerNOEXPAND                                    = 616
	TSqlLexerNON_TRANSACTED_ACCESS                       = 617
	TSqlLexerNORECOMPUTE                                 = 618
	TSqlLexerNORECOVERY                                  = 619
	TSqlLexerNOWAIT                                      = 620
	TSqlLexerNTILE                                       = 621
	TSqlLexerNUMANODE                                    = 622
	TSqlLexerNUMBER                                      = 623
	TSqlLexerNUMERIC_ROUNDABORT                          = 624
	TSqlLexerOBJECT                                      = 625
	TSqlLexerOFFLINE                                     = 626
	TSqlLexerOFFSET                                      = 627
	TSqlLexerOLD_ACCOUNT                                 = 628
	TSqlLexerONLINE                                      = 629
	TSqlLexerONLY                                        = 630
	TSqlLexerOPEN_EXISTING                               = 631
	TSqlLexerOPTIMISTIC                                  = 632
	TSqlLexerOPTIMIZE                                    = 633
	TSqlLexerOUT                                         = 634
	TSqlLexerOUTPUT                                      = 635
	TSqlLexerOWNER                                       = 636
	TSqlLexerPAGE_VERIFY                                 = 637
	TSqlLexerPARAMETERIZATION                            = 638
	TSqlLexerPARTITION                                   = 639
	TSqlLexerPARTITIONS                                  = 640
	TSqlLexerPARTNER                                     = 641
	TSqlLexerPATH                                        = 642
	TSqlLexerPOISON_MESSAGE_HANDLING                     = 643
	TSqlLexerPOOL                                        = 644
	TSqlLexerPORT                                        = 645
	TSqlLexerPRECEDING                                   = 646
	TSqlLexerPRIMARY_ROLE                                = 647
	TSqlLexerPRIOR                                       = 648
	TSqlLexerPRIORITY                                    = 649
	TSqlLexerPRIORITY_LEVEL                              = 650
	TSqlLexerPRIVATE                                     = 651
	TSqlLexerPRIVATE_KEY                                 = 652
	TSqlLexerPRIVILEGES                                  = 653
	TSqlLexerPROCEDURE_NAME                              = 654
	TSqlLexerPROPERTY                                    = 655
	TSqlLexerPROVIDER                                    = 656
	TSqlLexerPROVIDER_KEY_NAME                           = 657
	TSqlLexerQUERY                                       = 658
	TSqlLexerQUEUE                                       = 659
	TSqlLexerQUEUE_DELAY                                 = 660
	TSqlLexerQUOTED_IDENTIFIER                           = 661
	TSqlLexerRANGE                                       = 662
	TSqlLexerRANK                                        = 663
	TSqlLexerRC2                                         = 664
	TSqlLexerRC4                                         = 665
	TSqlLexerRC4_128                                     = 666
	TSqlLexerREAD_COMMITTED_SNAPSHOT                     = 667
	TSqlLexerREAD_ONLY                                   = 668
	TSqlLexerREAD_ONLY_ROUTING_LIST                      = 669
	TSqlLexerREAD_WRITE                                  = 670
	TSqlLexerREADONLY                                    = 671
	TSqlLexerREBUILD                                     = 672
	TSqlLexerRECEIVE                                     = 673
	TSqlLexerRECOMPILE                                   = 674
	TSqlLexerRECOVERY                                    = 675
	TSqlLexerRECURSIVE_TRIGGERS                          = 676
	TSqlLexerRELATIVE                                    = 677
	TSqlLexerREMOTE                                      = 678
	TSqlLexerREMOTE_SERVICE_NAME                         = 679
	TSqlLexerREMOVE                                      = 680
	TSqlLexerREORGANIZE                                  = 681
	TSqlLexerREPEATABLE                                  = 682
	TSqlLexerREPLICA                                     = 683
	TSqlLexerREQUEST_MAX_CPU_TIME_SEC                    = 684
	TSqlLexerREQUEST_MAX_MEMORY_GRANT_PERCENT            = 685
	TSqlLexerREQUEST_MEMORY_GRANT_TIMEOUT_SEC            = 686
	TSqlLexerREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT = 687
	TSqlLexerRESERVE_DISK_SPACE                          = 688
	TSqlLexerRESOURCE                                    = 689
	TSqlLexerRESOURCE_MANAGER_LOCATION                   = 690
	TSqlLexerRESTRICTED_USER                             = 691
	TSqlLexerRETENTION                                   = 692
	TSqlLexerROBUST                                      = 693
	TSqlLexerROOT                                        = 694
	TSqlLexerROUTE                                       = 695
	TSqlLexerROW                                         = 696
	TSqlLexerROW_NUMBER                                  = 697
	TSqlLexerROWGUID                                     = 698
	TSqlLexerROWS                                        = 699
	TSqlLexerSAMPLE                                      = 700
	TSqlLexerSCHEMABINDING                               = 701
	TSqlLexerSCOPED                                      = 702
	TSqlLexerSCROLL                                      = 703
	TSqlLexerSCROLL_LOCKS                                = 704
	TSqlLexerSEARCH                                      = 705
	TSqlLexerSECONDARY                                   = 706
	TSqlLexerSECONDARY_ONLY                              = 707
	TSqlLexerSECONDARY_ROLE                              = 708
	TSqlLexerSECONDS                                     = 709
	TSqlLexerSECRET                                      = 710
	TSqlLexerSECURITY_LOG                                = 711
	TSqlLexerSEEDING_MODE                                = 712
	TSqlLexerSELF                                        = 713
	TSqlLexerSEMI_SENSITIVE                              = 714
	TSqlLexerSEND                                        = 715
	TSqlLexerSENT                                        = 716
	TSqlLexerSERIALIZABLE                                = 717
	TSqlLexerSESSION_TIMEOUT                             = 718
	TSqlLexerSETERROR                                    = 719
	TSqlLexerSHARE                                       = 720
	TSqlLexerSHOWPLAN                                    = 721
	TSqlLexerSIGNATURE                                   = 722
	TSqlLexerSIMPLE                                      = 723
	TSqlLexerSINGLE_USER                                 = 724
	TSqlLexerSIZE                                        = 725
	TSqlLexerSMALLINT                                    = 726
	TSqlLexerSNAPSHOT                                    = 727
	TSqlLexerSPATIAL_WINDOW_MAX_CELLS                    = 728
	TSqlLexerSTANDBY                                     = 729
	TSqlLexerSTART_DATE                                  = 730
	TSqlLexerSTATIC                                      = 731
	TSqlLexerSTATS_STREAM                                = 732
	TSqlLexerSTATUS                                      = 733
	TSqlLexerSTDEV                                       = 734
	TSqlLexerSTDEVP                                      = 735
	TSqlLexerSTOPLIST                                    = 736
	TSqlLexerSTUFF                                       = 737
	TSqlLexerSUBJECT                                     = 738
	TSqlLexerSUM                                         = 739
	TSqlLexerSUSPEND                                     = 740
	TSqlLexerSYMMETRIC                                   = 741
	TSqlLexerSYNCHRONOUS_COMMIT                          = 742
	TSqlLexerSYNONYM                                     = 743
	TSqlLexerTAKE                                        = 744
	TSqlLexerTARGET_RECOVERY_TIME                        = 745
	TSqlLexerTB                                          = 746
	TSqlLexerTEXTIMAGE_ON                                = 747
	TSqlLexerTHROW                                       = 748
	TSqlLexerTIES                                        = 749
	TSqlLexerTIME                                        = 750
	TSqlLexerTIMEOUT                                     = 751
	TSqlLexerTIMER                                       = 752
	TSqlLexerTINYINT                                     = 753
	TSqlLexerTORN_PAGE_DETECTION                         = 754
	TSqlLexerTRANSFORM_NOISE_WORDS                       = 755
	TSqlLexerTRIPLE_DES                                  = 756
	TSqlLexerTRIPLE_DES_3KEY                             = 757
	TSqlLexerTRUSTWORTHY                                 = 758
	TSqlLexerTRY                                         = 759
	TSqlLexerTSQL                                        = 760
	TSqlLexerTWO_DIGIT_YEAR_CUTOFF                       = 761
	TSqlLexerTYPE                                        = 762
	TSqlLexerTYPE_WARNING                                = 763
	TSqlLexerUNBOUNDED                                   = 764
	TSqlLexerUNCOMMITTED                                 = 765
	TSqlLexerUNKNOWN                                     = 766
	TSqlLexerUNLIMITED                                   = 767
	TSqlLexerUSING                                       = 768
	TSqlLexerVALID_XML                                   = 769
	TSqlLexerVALIDATION                                  = 770
	TSqlLexerVALUE                                       = 771
	TSqlLexerVAR                                         = 772
	TSqlLexerVARP                                        = 773
	TSqlLexerVIEW_METADATA                               = 774
	TSqlLexerVIEWS                                       = 775
	TSqlLexerWAIT                                        = 776
	TSqlLexerWELL_FORMED_XML                             = 777
	TSqlLexerWITHOUT_ARRAY_WRAPPER                       = 778
	TSqlLexerWORK                                        = 779
	TSqlLexerWORKLOAD                                    = 780
	TSqlLexerXML                                         = 781
	TSqlLexerXMLDATA                                     = 782
	TSqlLexerXMLNAMESPACES                               = 783
	TSqlLexerXMLSCHEMA                                   = 784
	TSqlLexerXSINIL                                      = 785
	TSqlLexerDOLLAR_ACTION                               = 786
	TSqlLexerSPACE                                       = 787
	TSqlLexerCOMMENT                                     = 788
	TSqlLexerLINE_COMMENT                                = 789
	TSqlLexerDOUBLE_QUOTE_ID                             = 790
	TSqlLexerSINGLE_QUOTE                                = 791
	TSqlLexerSQUARE_BRACKET_ID                           = 792
	TSqlLexerLOCAL_ID                                    = 793
	TSqlLexerDECIMAL                                     = 794
	TSqlLexerID                                          = 795
	TSqlLexerQUOTED_URL                                  = 796
	TSqlLexerQUOTED_HOST_AND_PORT                        = 797
	TSqlLexerSTRING                                      = 798
	TSqlLexerBINARY                                      = 799
	TSqlLexerFLOAT                                       = 800
	TSqlLexerREAL                                        = 801
	TSqlLexerEQUAL                                       = 802
	TSqlLexerGREATER                                     = 803
	TSqlLexerLESS                                        = 804
	TSqlLexerEXCLAMATION                                 = 805
	TSqlLexerPLUS_ASSIGN                                 = 806
	TSqlLexerMINUS_ASSIGN                                = 807
	TSqlLexerMULT_ASSIGN                                 = 808
	TSqlLexerDIV_ASSIGN                                  = 809
	TSqlLexerMOD_ASSIGN                                  = 810
	TSqlLexerAND_ASSIGN                                  = 811
	TSqlLexerXOR_ASSIGN                                  = 812
	TSqlLexerOR_ASSIGN                                   = 813
	TSqlLexerDOUBLE_BAR                                  = 814
	TSqlLexerDOT                                         = 815
	TSqlLexerUNDERLINE                                   = 816
	TSqlLexerAT                                          = 817
	TSqlLexerSHARP                                       = 818
	TSqlLexerDOLLAR                                      = 819
	TSqlLexerLR_BRACKET                                  = 820
	TSqlLexerRR_BRACKET                                  = 821
	TSqlLexerCOMMA                                       = 822
	TSqlLexerSEMI                                        = 823
	TSqlLexerCOLON                                       = 824
	TSqlLexerSTAR                                        = 825
	TSqlLexerDIVIDE                                      = 826
	TSqlLexerMODULE                                      = 827
	TSqlLexerPLUS                                        = 828
	TSqlLexerMINUS                                       = 829
	TSqlLexerBIT_NOT                                     = 830
	TSqlLexerBIT_OR                                      = 831
	TSqlLexerBIT_AND                                     = 832
	TSqlLexerBIT_XOR                                     = 833
	TSqlLexerIPV4_OCTECT                                 = 834
)

TSqlLexer tokens.

View Source
const (
	TSqlParserEOF                                         = antlr.TokenEOF
	TSqlParserABSENT                                      = 1
	TSqlParserADD                                         = 2
	TSqlParserAES                                         = 3
	TSqlParserALL                                         = 4
	TSqlParserALLOW_CONNECTIONS                           = 5
	TSqlParserALLOW_MULTIPLE_EVENT_LOSS                   = 6
	TSqlParserALLOW_SINGLE_EVENT_LOSS                     = 7
	TSqlParserALTER                                       = 8
	TSqlParserAND                                         = 9
	TSqlParserANONYMOUS                                   = 10
	TSqlParserANY                                         = 11
	TSqlParserAPPEND                                      = 12
	TSqlParserAPPLICATION                                 = 13
	TSqlParserAS                                          = 14
	TSqlParserASC                                         = 15
	TSqlParserASYMMETRIC                                  = 16
	TSqlParserASYNCHRONOUS_COMMIT                         = 17
	TSqlParserAUTHORIZATION                               = 18
	TSqlParserAUTHENTICATION                              = 19
	TSqlParserAUTOMATED_BACKUP_PREFERENCE                 = 20
	TSqlParserAUTOMATIC                                   = 21
	TSqlParserAVAILABILITY_MODE                           = 22
	TSqlParserBACKSLASH                                   = 23
	TSqlParserBACKUP                                      = 24
	TSqlParserBEFORE                                      = 25
	TSqlParserBEGIN                                       = 26
	TSqlParserBETWEEN                                     = 27
	TSqlParserBLOCK                                       = 28
	TSqlParserBLOCKSIZE                                   = 29
	TSqlParserBLOCKING_HIERARCHY                          = 30
	TSqlParserBREAK                                       = 31
	TSqlParserBROWSE                                      = 32
	TSqlParserBUFFER                                      = 33
	TSqlParserBUFFERCOUNT                                 = 34
	TSqlParserBULK                                        = 35
	TSqlParserBY                                          = 36
	TSqlParserCACHE                                       = 37
	TSqlParserCALLED                                      = 38
	TSqlParserCASCADE                                     = 39
	TSqlParserCASE                                        = 40
	TSqlParserCERTIFICATE                                 = 41
	TSqlParserCHANGETABLE                                 = 42
	TSqlParserCHANGES                                     = 43
	TSqlParserCHECK                                       = 44
	TSqlParserCHECKPOINT                                  = 45
	TSqlParserCHECK_POLICY                                = 46
	TSqlParserCHECK_EXPIRATION                            = 47
	TSqlParserCLASSIFIER_FUNCTION                         = 48
	TSqlParserCLOSE                                       = 49
	TSqlParserCLUSTER                                     = 50
	TSqlParserCLUSTERED                                   = 51
	TSqlParserCOALESCE                                    = 52
	TSqlParserCOLLATE                                     = 53
	TSqlParserCOLUMN                                      = 54
	TSqlParserCOMPRESSION                                 = 55
	TSqlParserCOMMIT                                      = 56
	TSqlParserCOMPUTE                                     = 57
	TSqlParserCONFIGURATION                               = 58
	TSqlParserCONSTRAINT                                  = 59
	TSqlParserCONTAINMENT                                 = 60
	TSqlParserCONTAINS                                    = 61
	TSqlParserCONTAINSTABLE                               = 62
	TSqlParserCONTEXT                                     = 63
	TSqlParserCONTINUE                                    = 64
	TSqlParserCONTINUE_AFTER_ERROR                        = 65
	TSqlParserCONTRACT                                    = 66
	TSqlParserCONTRACT_NAME                               = 67
	TSqlParserCONVERSATION                                = 68
	TSqlParserCONVERT                                     = 69
	TSqlParserCOPY_ONLY                                   = 70
	TSqlParserCREATE                                      = 71
	TSqlParserCROSS                                       = 72
	TSqlParserCURRENT                                     = 73
	TSqlParserCURRENT_DATE                                = 74
	TSqlParserCURRENT_TIME                                = 75
	TSqlParserCURRENT_TIMESTAMP                           = 76
	TSqlParserCURRENT_USER                                = 77
	TSqlParserCURSOR                                      = 78
	TSqlParserCYCLE                                       = 79
	TSqlParserDATA                                        = 80
	TSqlParserDATA_COMPRESSION                            = 81
	TSqlParserDATA_SOURCE                                 = 82
	TSqlParserDATABASE                                    = 83
	TSqlParserDATABASE_MIRRORING                          = 84
	TSqlParserDBCC                                        = 85
	TSqlParserDEALLOCATE                                  = 86
	TSqlParserDECLARE                                     = 87
	TSqlParserDEFAULT                                     = 88
	TSqlParserDEFAULT_DATABASE                            = 89
	TSqlParserDEFAULT_SCHEMA                              = 90
	TSqlParserDELETE                                      = 91
	TSqlParserDENY                                        = 92
	TSqlParserDESC                                        = 93
	TSqlParserDIAGNOSTICS                                 = 94
	TSqlParserDIFFERENTIAL                                = 95
	TSqlParserDISK                                        = 96
	TSqlParserDISTINCT                                    = 97
	TSqlParserDISTRIBUTED                                 = 98
	TSqlParserDOUBLE                                      = 99
	TSqlParserDOUBLE_BACK_SLASH                           = 100
	TSqlParserDOUBLE_FORWARD_SLASH                        = 101
	TSqlParserDROP                                        = 102
	TSqlParserDTC_SUPPORT                                 = 103
	TSqlParserDUMP                                        = 104
	TSqlParserELSE                                        = 105
	TSqlParserENABLED                                     = 106
	TSqlParserEND                                         = 107
	TSqlParserENDPOINT                                    = 108
	TSqlParserERRLVL                                      = 109
	TSqlParserESCAPE                                      = 110
	TSqlParserERROR                                       = 111
	TSqlParserEVENT                                       = 112
	TSqlParserEVENTDATA                                   = 113
	TSqlParserEVENT_RETENTION_MODE                        = 114
	TSqlParserEXCEPT                                      = 115
	TSqlParserEXECUTABLE_FILE                             = 116
	TSqlParserEXECUTE                                     = 117
	TSqlParserEXISTS                                      = 118
	TSqlParserEXPIREDATE                                  = 119
	TSqlParserEXIT                                        = 120
	TSqlParserEXTENSION                                   = 121
	TSqlParserEXTERNAL                                    = 122
	TSqlParserEXTERNAL_ACCESS                             = 123
	TSqlParserFAILOVER                                    = 124
	TSqlParserFAILURECONDITIONLEVEL                       = 125
	TSqlParserFAN_IN                                      = 126
	TSqlParserFETCH                                       = 127
	TSqlParserFILE                                        = 128
	TSqlParserFILENAME                                    = 129
	TSqlParserFILLFACTOR                                  = 130
	TSqlParserFILE_SNAPSHOT                               = 131
	TSqlParserFOR                                         = 132
	TSqlParserFORCESEEK                                   = 133
	TSqlParserFORCE_SERVICE_ALLOW_DATA_LOSS               = 134
	TSqlParserFOREIGN                                     = 135
	TSqlParserFREETEXT                                    = 136
	TSqlParserFREETEXTTABLE                               = 137
	TSqlParserFROM                                        = 138
	TSqlParserFULL                                        = 139
	TSqlParserFUNCTION                                    = 140
	TSqlParserGET                                         = 141
	TSqlParserGOTO                                        = 142
	TSqlParserGOVERNOR                                    = 143
	TSqlParserGRANT                                       = 144
	TSqlParserGROUP                                       = 145
	TSqlParserHAVING                                      = 146
	TSqlParserHASHED                                      = 147
	TSqlParserHEALTHCHECKTIMEOUT                          = 148
	TSqlParserIDENTITY                                    = 149
	TSqlParserIDENTITYCOL                                 = 150
	TSqlParserIDENTITY_INSERT                             = 151
	TSqlParserIF                                          = 152
	TSqlParserIIF                                         = 153
	TSqlParserIN                                          = 154
	TSqlParserINCLUDE                                     = 155
	TSqlParserINCREMENT                                   = 156
	TSqlParserINDEX                                       = 157
	TSqlParserINFINITE                                    = 158
	TSqlParserINIT                                        = 159
	TSqlParserINNER                                       = 160
	TSqlParserINSERT                                      = 161
	TSqlParserINSTEAD                                     = 162
	TSqlParserINTERSECT                                   = 163
	TSqlParserINTO                                        = 164
	TSqlParserIPV4_ADDR                                   = 165
	TSqlParserIPV6_ADDR                                   = 166
	TSqlParserIS                                          = 167
	TSqlParserISNULL                                      = 168
	TSqlParserJOIN                                        = 169
	TSqlParserKERBEROS                                    = 170
	TSqlParserKEY                                         = 171
	TSqlParserKEY_PATH                                    = 172
	TSqlParserKEY_STORE_PROVIDER_NAME                     = 173
	TSqlParserKILL                                        = 174
	TSqlParserLANGUAGE                                    = 175
	TSqlParserLEFT                                        = 176
	TSqlParserLIBRARY                                     = 177
	TSqlParserLIFETIME                                    = 178
	TSqlParserLIKE                                        = 179
	TSqlParserLINENO                                      = 180
	TSqlParserLINUX                                       = 181
	TSqlParserLISTENER_IP                                 = 182
	TSqlParserLISTENER_PORT                               = 183
	TSqlParserLOAD                                        = 184
	TSqlParserLOCAL_SERVICE_NAME                          = 185
	TSqlParserLOG                                         = 186
	TSqlParserMATCHED                                     = 187
	TSqlParserMASTER                                      = 188
	TSqlParserMAX_MEMORY                                  = 189
	TSqlParserMAXTRANSFER                                 = 190
	TSqlParserMAXVALUE                                    = 191
	TSqlParserMAX_DISPATCH_LATENCY                        = 192
	TSqlParserMAX_EVENT_SIZE                              = 193
	TSqlParserMAX_SIZE                                    = 194
	TSqlParserMAX_OUTSTANDING_IO_PER_VOLUME               = 195
	TSqlParserMEDIADESCRIPTION                            = 196
	TSqlParserMEDIANAME                                   = 197
	TSqlParserMEMBER                                      = 198
	TSqlParserMEMORY_PARTITION_MODE                       = 199
	TSqlParserMERGE                                       = 200
	TSqlParserMESSAGE_FORWARDING                          = 201
	TSqlParserMESSAGE_FORWARD_SIZE                        = 202
	TSqlParserMINVALUE                                    = 203
	TSqlParserMIRROR                                      = 204
	TSqlParserMUST_CHANGE                                 = 205
	TSqlParserNATIONAL                                    = 206
	TSqlParserNEGOTIATE                                   = 207
	TSqlParserNOCHECK                                     = 208
	TSqlParserNOFORMAT                                    = 209
	TSqlParserNOINIT                                      = 210
	TSqlParserNONCLUSTERED                                = 211
	TSqlParserNONE                                        = 212
	TSqlParserNOREWIND                                    = 213
	TSqlParserNOSKIP                                      = 214
	TSqlParserNOUNLOAD                                    = 215
	TSqlParserNO_CHECKSUM                                 = 216
	TSqlParserNO_COMPRESSION                              = 217
	TSqlParserNO_EVENT_LOSS                               = 218
	TSqlParserNOT                                         = 219
	TSqlParserNOTIFICATION                                = 220
	TSqlParserNTLM                                        = 221
	TSqlParserNULL                                        = 222
	TSqlParserNULLIF                                      = 223
	TSqlParserOF                                          = 224
	TSqlParserOFF                                         = 225
	TSqlParserOFFSETS                                     = 226
	TSqlParserOLD_PASSWORD                                = 227
	TSqlParserON                                          = 228
	TSqlParserON_FAILURE                                  = 229
	TSqlParserOPEN                                        = 230
	TSqlParserOPENDATASOURCE                              = 231
	TSqlParserOPENQUERY                                   = 232
	TSqlParserOPENROWSET                                  = 233
	TSqlParserOPENXML                                     = 234
	TSqlParserOPTION                                      = 235
	TSqlParserOR                                          = 236
	TSqlParserORDER                                       = 237
	TSqlParserOUTER                                       = 238
	TSqlParserOVER                                        = 239
	TSqlParserPAGE                                        = 240
	TSqlParserPARAM_NODE                                  = 241
	TSqlParserPARTIAL                                     = 242
	TSqlParserPASSWORD                                    = 243
	TSqlParserPERCENT                                     = 244
	TSqlParserPERMISSION_SET                              = 245
	TSqlParserPER_CPU                                     = 246
	TSqlParserPER_DB                                      = 247
	TSqlParserPER_NODE                                    = 248
	TSqlParserPIVOT                                       = 249
	TSqlParserPLAN                                        = 250
	TSqlParserPLATFORM                                    = 251
	TSqlParserPOLICY                                      = 252
	TSqlParserPRECISION                                   = 253
	TSqlParserPREDICATE                                   = 254
	TSqlParserPRIMARY                                     = 255
	TSqlParserPRINT                                       = 256
	TSqlParserPROC                                        = 257
	TSqlParserPROCEDURE                                   = 258
	TSqlParserPROCESS                                     = 259
	TSqlParserPUBLIC                                      = 260
	TSqlParserPYTHON                                      = 261
	TSqlParserR                                           = 262
	TSqlParserRAISERROR                                   = 263
	TSqlParserRAW                                         = 264
	TSqlParserREAD                                        = 265
	TSqlParserREADTEXT                                    = 266
	TSqlParserREAD_WRITE_FILEGROUPS                       = 267
	TSqlParserRECONFIGURE                                 = 268
	TSqlParserREFERENCES                                  = 269
	TSqlParserREGENERATE                                  = 270
	TSqlParserRELATED_CONVERSATION                        = 271
	TSqlParserRELATED_CONVERSATION_GROUP                  = 272
	TSqlParserREPLICATION                                 = 273
	TSqlParserREQUIRED                                    = 274
	TSqlParserRESET                                       = 275
	TSqlParserRESTART                                     = 276
	TSqlParserRESTORE                                     = 277
	TSqlParserRESTRICT                                    = 278
	TSqlParserRESUME                                      = 279
	TSqlParserRETAINDAYS                                  = 280
	TSqlParserRETURN                                      = 281
	TSqlParserRETURNS                                     = 282
	TSqlParserREVERT                                      = 283
	TSqlParserREVOKE                                      = 284
	TSqlParserREWIND                                      = 285
	TSqlParserRIGHT                                       = 286
	TSqlParserROLLBACK                                    = 287
	TSqlParserROLE                                        = 288
	TSqlParserROWCOUNT                                    = 289
	TSqlParserROWGUIDCOL                                  = 290
	TSqlParserRSA_512                                     = 291
	TSqlParserRSA_1024                                    = 292
	TSqlParserRSA_2048                                    = 293
	TSqlParserRSA_3072                                    = 294
	TSqlParserRSA_4096                                    = 295
	TSqlParserSAFETY                                      = 296
	TSqlParserRULE                                        = 297
	TSqlParserSAFE                                        = 298
	TSqlParserSAVE                                        = 299
	TSqlParserSCHEDULER                                   = 300
	TSqlParserSCHEMA                                      = 301
	TSqlParserSCHEME                                      = 302
	TSqlParserSECURITY                                    = 303
	TSqlParserSECURITYAUDIT                               = 304
	TSqlParserSELECT                                      = 305
	TSqlParserSEMANTICKEYPHRASETABLE                      = 306
	TSqlParserSEMANTICSIMILARITYDETAILSTABLE              = 307
	TSqlParserSEMANTICSIMILARITYTABLE                     = 308
	TSqlParserSEQUENCE                                    = 309
	TSqlParserSERVER                                      = 310
	TSqlParserSERVICE                                     = 311
	TSqlParserSERVICE_BROKER                              = 312
	TSqlParserSERVICE_NAME                                = 313
	TSqlParserSESSION                                     = 314
	TSqlParserSESSION_USER                                = 315
	TSqlParserSET                                         = 316
	TSqlParserSETUSER                                     = 317
	TSqlParserSHUTDOWN                                    = 318
	TSqlParserSID                                         = 319
	TSqlParserSKIP_KEYWORD                                = 320
	TSqlParserSOFTNUMA                                    = 321
	TSqlParserSOME                                        = 322
	TSqlParserSOURCE                                      = 323
	TSqlParserSPECIFICATION                               = 324
	TSqlParserSPLIT                                       = 325
	TSqlParserSQLDUMPERFLAGS                              = 326
	TSqlParserSQLDUMPERPATH                               = 327
	TSqlParserSQLDUMPERTIMEOUT                            = 328
	TSqlParserSTATISTICS                                  = 329
	TSqlParserSTATE                                       = 330
	TSqlParserSTATS                                       = 331
	TSqlParserSTART                                       = 332
	TSqlParserSTARTED                                     = 333
	TSqlParserSTARTUP_STATE                               = 334
	TSqlParserSTOP                                        = 335
	TSqlParserSTOPPED                                     = 336
	TSqlParserSTOP_ON_ERROR                               = 337
	TSqlParserSUPPORTED                                   = 338
	TSqlParserSYSTEM                                      = 339
	TSqlParserSYSTEM_USER                                 = 340
	TSqlParserTABLE                                       = 341
	TSqlParserTABLESAMPLE                                 = 342
	TSqlParserTAPE                                        = 343
	TSqlParserTARGET                                      = 344
	TSqlParserTCP                                         = 345
	TSqlParserTEXTSIZE                                    = 346
	TSqlParserTHEN                                        = 347
	TSqlParserTO                                          = 348
	TSqlParserTOP                                         = 349
	TSqlParserTRACK_CAUSALITY                             = 350
	TSqlParserTRAN                                        = 351
	TSqlParserTRANSACTION                                 = 352
	TSqlParserTRANSFER                                    = 353
	TSqlParserTRIGGER                                     = 354
	TSqlParserTRUNCATE                                    = 355
	TSqlParserTSEQUAL                                     = 356
	TSqlParserUNCHECKED                                   = 357
	TSqlParserUNION                                       = 358
	TSqlParserUNIQUE                                      = 359
	TSqlParserUNLOCK                                      = 360
	TSqlParserUNPIVOT                                     = 361
	TSqlParserUNSAFE                                      = 362
	TSqlParserUPDATE                                      = 363
	TSqlParserUPDATETEXT                                  = 364
	TSqlParserURL                                         = 365
	TSqlParserUSE                                         = 366
	TSqlParserUSED                                        = 367
	TSqlParserUSER                                        = 368
	TSqlParserVALUES                                      = 369
	TSqlParserVARYING                                     = 370
	TSqlParserVERBOSELOGGING                              = 371
	TSqlParserVIEW                                        = 372
	TSqlParserVISIBILITY                                  = 373
	TSqlParserWAITFOR                                     = 374
	TSqlParserWHEN                                        = 375
	TSqlParserWHERE                                       = 376
	TSqlParserWHILE                                       = 377
	TSqlParserWINDOWS                                     = 378
	TSqlParserWITH                                        = 379
	TSqlParserWITHIN                                      = 380
	TSqlParserWITHOUT                                     = 381
	TSqlParserWITNESS                                     = 382
	TSqlParserWRITETEXT                                   = 383
	TSqlParserABSOLUTE                                    = 384
	TSqlParserACCENT_SENSITIVITY                          = 385
	TSqlParserACTION                                      = 386
	TSqlParserACTIVATION                                  = 387
	TSqlParserACTIVE                                      = 388
	TSqlParserADDRESS                                     = 389
	TSqlParserAES_128                                     = 390
	TSqlParserAES_192                                     = 391
	TSqlParserAES_256                                     = 392
	TSqlParserAFFINITY                                    = 393
	TSqlParserAFTER                                       = 394
	TSqlParserAGGREGATE                                   = 395
	TSqlParserALGORITHM                                   = 396
	TSqlParserALLOW_ENCRYPTED_VALUE_MODIFICATIONS         = 397
	TSqlParserALLOW_SNAPSHOT_ISOLATION                    = 398
	TSqlParserALLOWED                                     = 399
	TSqlParserANSI_NULL_DEFAULT                           = 400
	TSqlParserANSI_NULLS                                  = 401
	TSqlParserANSI_PADDING                                = 402
	TSqlParserANSI_WARNINGS                               = 403
	TSqlParserAPPLICATION_LOG                             = 404
	TSqlParserAPPLY                                       = 405
	TSqlParserARITHABORT                                  = 406
	TSqlParserASSEMBLY                                    = 407
	TSqlParserAUDIT                                       = 408
	TSqlParserAUDIT_GUID                                  = 409
	TSqlParserAUTO                                        = 410
	TSqlParserAUTO_CLEANUP                                = 411
	TSqlParserAUTO_CLOSE                                  = 412
	TSqlParserAUTO_CREATE_STATISTICS                      = 413
	TSqlParserAUTO_SHRINK                                 = 414
	TSqlParserAUTO_UPDATE_STATISTICS                      = 415
	TSqlParserAUTO_UPDATE_STATISTICS_ASYNC                = 416
	TSqlParserAVAILABILITY                                = 417
	TSqlParserAVG                                         = 418
	TSqlParserBACKUP_PRIORITY                             = 419
	TSqlParserBEGIN_DIALOG                                = 420
	TSqlParserBIGINT                                      = 421
	TSqlParserBINARY_BASE64                               = 422
	TSqlParserBINARY_CHECKSUM                             = 423
	TSqlParserBINDING                                     = 424
	TSqlParserBLOB_STORAGE                                = 425
	TSqlParserBROKER                                      = 426
	TSqlParserBROKER_INSTANCE                             = 427
	TSqlParserBULK_LOGGED                                 = 428
	TSqlParserCALLER                                      = 429
	TSqlParserCAP_CPU_PERCENT                             = 430
	TSqlParserCAST                                        = 431
	TSqlParserCATALOG                                     = 432
	TSqlParserCATCH                                       = 433
	TSqlParserCHANGE_RETENTION                            = 434
	TSqlParserCHANGE_TRACKING                             = 435
	TSqlParserCHECKSUM                                    = 436
	TSqlParserCHECKSUM_AGG                                = 437
	TSqlParserCLEANUP                                     = 438
	TSqlParserCOLLECTION                                  = 439
	TSqlParserCOLUMN_MASTER_KEY                           = 440
	TSqlParserCOMMITTED                                   = 441
	TSqlParserCOMPATIBILITY_LEVEL                         = 442
	TSqlParserCONCAT                                      = 443
	TSqlParserCONCAT_NULL_YIELDS_NULL                     = 444
	TSqlParserCONTENT                                     = 445
	TSqlParserCONTROL                                     = 446
	TSqlParserCOOKIE                                      = 447
	TSqlParserCOUNT                                       = 448
	TSqlParserCOUNT_BIG                                   = 449
	TSqlParserCOUNTER                                     = 450
	TSqlParserCPU                                         = 451
	TSqlParserCREATE_NEW                                  = 452
	TSqlParserCREATION_DISPOSITION                        = 453
	TSqlParserCREDENTIAL                                  = 454
	TSqlParserCRYPTOGRAPHIC                               = 455
	TSqlParserCURSOR_CLOSE_ON_COMMIT                      = 456
	TSqlParserCURSOR_DEFAULT                              = 457
	TSqlParserDATE_CORRELATION_OPTIMIZATION               = 458
	TSqlParserDATEADD                                     = 459
	TSqlParserDATEDIFF                                    = 460
	TSqlParserDATENAME                                    = 461
	TSqlParserDATEPART                                    = 462
	TSqlParserDAYS                                        = 463
	TSqlParserDB_CHAINING                                 = 464
	TSqlParserDB_FAILOVER                                 = 465
	TSqlParserDECRYPTION                                  = 466
	TSqlParserDEFAULT_DOUBLE_QUOTE                        = 467
	TSqlParserDEFAULT_FULLTEXT_LANGUAGE                   = 468
	TSqlParserDEFAULT_LANGUAGE                            = 469
	TSqlParserDELAY                                       = 470
	TSqlParserDELAYED_DURABILITY                          = 471
	TSqlParserDELETED                                     = 472
	TSqlParserDENSE_RANK                                  = 473
	TSqlParserDEPENDENTS                                  = 474
	TSqlParserDES                                         = 475
	TSqlParserDESCRIPTION                                 = 476
	TSqlParserDESX                                        = 477
	TSqlParserDHCP                                        = 478
	TSqlParserDIALOG                                      = 479
	TSqlParserDIRECTORY_NAME                              = 480
	TSqlParserDISABLE                                     = 481
	TSqlParserDISABLE_BROKER                              = 482
	TSqlParserDISABLED                                    = 483
	TSqlParserDISK_DRIVE                                  = 484
	TSqlParserDOCUMENT                                    = 485
	TSqlParserDYNAMIC                                     = 486
	TSqlParserELEMENTS                                    = 487
	TSqlParserEMERGENCY                                   = 488
	TSqlParserEMPTY                                       = 489
	TSqlParserENABLE                                      = 490
	TSqlParserENABLE_BROKER                               = 491
	TSqlParserENCRYPTED_VALUE                             = 492
	TSqlParserENCRYPTION                                  = 493
	TSqlParserENDPOINT_URL                                = 494
	TSqlParserERROR_BROKER_CONVERSATIONS                  = 495
	TSqlParserEXCLUSIVE                                   = 496
	TSqlParserEXECUTABLE                                  = 497
	TSqlParserEXIST                                       = 498
	TSqlParserEXPAND                                      = 499
	TSqlParserEXPIRY_DATE                                 = 500
	TSqlParserEXPLICIT                                    = 501
	TSqlParserFAIL_OPERATION                              = 502
	TSqlParserFAILOVER_MODE                               = 503
	TSqlParserFAILURE                                     = 504
	TSqlParserFAILURE_CONDITION_LEVEL                     = 505
	TSqlParserFAST                                        = 506
	TSqlParserFAST_FORWARD                                = 507
	TSqlParserFILEGROUP                                   = 508
	TSqlParserFILEGROWTH                                  = 509
	TSqlParserFILEPATH                                    = 510
	TSqlParserFILESTREAM                                  = 511
	TSqlParserFILTER                                      = 512
	TSqlParserFIRST                                       = 513
	TSqlParserFIRST_VALUE                                 = 514
	TSqlParserFOLLOWING                                   = 515
	TSqlParserFORCE                                       = 516
	TSqlParserFORCE_FAILOVER_ALLOW_DATA_LOSS              = 517
	TSqlParserFORCED                                      = 518
	TSqlParserFORMAT                                      = 519
	TSqlParserFORWARD_ONLY                                = 520
	TSqlParserFULLSCAN                                    = 521
	TSqlParserFULLTEXT                                    = 522
	TSqlParserGB                                          = 523
	TSqlParserGETDATE                                     = 524
	TSqlParserGETUTCDATE                                  = 525
	TSqlParserGLOBAL                                      = 526
	TSqlParserGO                                          = 527
	TSqlParserGROUP_MAX_REQUESTS                          = 528
	TSqlParserGROUPING                                    = 529
	TSqlParserGROUPING_ID                                 = 530
	TSqlParserHADR                                        = 531
	TSqlParserHASH                                        = 532
	TSqlParserHEALTH_CHECK_TIMEOUT                        = 533
	TSqlParserHIGH                                        = 534
	TSqlParserHONOR_BROKER_PRIORITY                       = 535
	TSqlParserHOURS                                       = 536
	TSqlParserIDENTITY_VALUE                              = 537
	TSqlParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX       = 538
	TSqlParserIMMEDIATE                                   = 539
	TSqlParserIMPERSONATE                                 = 540
	TSqlParserIMPORTANCE                                  = 541
	TSqlParserINCLUDE_NULL_VALUES                         = 542
	TSqlParserINCREMENTAL                                 = 543
	TSqlParserINITIATOR                                   = 544
	TSqlParserINPUT                                       = 545
	TSqlParserINSENSITIVE                                 = 546
	TSqlParserINSERTED                                    = 547
	TSqlParserINT                                         = 548
	TSqlParserIP                                          = 549
	TSqlParserISOLATION                                   = 550
	TSqlParserJSON                                        = 551
	TSqlParserKB                                          = 552
	TSqlParserKEEP                                        = 553
	TSqlParserKEEPFIXED                                   = 554
	TSqlParserKEY_SOURCE                                  = 555
	TSqlParserKEYS                                        = 556
	TSqlParserKEYSET                                      = 557
	TSqlParserLAG                                         = 558
	TSqlParserLAST                                        = 559
	TSqlParserLAST_VALUE                                  = 560
	TSqlParserLEAD                                        = 561
	TSqlParserLEVEL                                       = 562
	TSqlParserLIST                                        = 563
	TSqlParserLISTENER                                    = 564
	TSqlParserLISTENER_URL                                = 565
	TSqlParserLOB_COMPACTION                              = 566
	TSqlParserLOCAL                                       = 567
	TSqlParserLOCATION                                    = 568
	TSqlParserLOCK                                        = 569
	TSqlParserLOCK_ESCALATION                             = 570
	TSqlParserLOGIN                                       = 571
	TSqlParserLOOP                                        = 572
	TSqlParserLOW                                         = 573
	TSqlParserMANUAL                                      = 574
	TSqlParserMARK                                        = 575
	TSqlParserMATERIALIZED                                = 576
	TSqlParserMAX                                         = 577
	TSqlParserMAX_CPU_PERCENT                             = 578
	TSqlParserMAX_DOP                                     = 579
	TSqlParserMAX_FILES                                   = 580
	TSqlParserMAX_IOPS_PER_VOLUME                         = 581
	TSqlParserMAX_MEMORY_PERCENT                          = 582
	TSqlParserMAX_PROCESSES                               = 583
	TSqlParserMAX_QUEUE_READERS                           = 584
	TSqlParserMAX_ROLLOVER_FILES                          = 585
	TSqlParserMAXDOP                                      = 586
	TSqlParserMAXRECURSION                                = 587
	TSqlParserMAXSIZE                                     = 588
	TSqlParserMB                                          = 589
	TSqlParserMEDIUM                                      = 590
	TSqlParserMEMORY_OPTIMIZED_DATA                       = 591
	TSqlParserMESSAGE                                     = 592
	TSqlParserMIN                                         = 593
	TSqlParserMIN_ACTIVE_ROWVERSION                       = 594
	TSqlParserMIN_CPU_PERCENT                             = 595
	TSqlParserMIN_IOPS_PER_VOLUME                         = 596
	TSqlParserMIN_MEMORY_PERCENT                          = 597
	TSqlParserMINUTES                                     = 598
	TSqlParserMIRROR_ADDRESS                              = 599
	TSqlParserMIXED_PAGE_ALLOCATION                       = 600
	TSqlParserMODE                                        = 601
	TSqlParserMODIFY                                      = 602
	TSqlParserMOVE                                        = 603
	TSqlParserMULTI_USER                                  = 604
	TSqlParserNAME                                        = 605
	TSqlParserNESTED_TRIGGERS                             = 606
	TSqlParserNEW_ACCOUNT                                 = 607
	TSqlParserNEW_BROKER                                  = 608
	TSqlParserNEW_PASSWORD                                = 609
	TSqlParserNEXT                                        = 610
	TSqlParserNO                                          = 611
	TSqlParserNO_TRUNCATE                                 = 612
	TSqlParserNO_WAIT                                     = 613
	TSqlParserNOCOUNT                                     = 614
	TSqlParserNODES                                       = 615
	TSqlParserNOEXPAND                                    = 616
	TSqlParserNON_TRANSACTED_ACCESS                       = 617
	TSqlParserNORECOMPUTE                                 = 618
	TSqlParserNORECOVERY                                  = 619
	TSqlParserNOWAIT                                      = 620
	TSqlParserNTILE                                       = 621
	TSqlParserNUMANODE                                    = 622
	TSqlParserNUMBER                                      = 623
	TSqlParserNUMERIC_ROUNDABORT                          = 624
	TSqlParserOBJECT                                      = 625
	TSqlParserOFFLINE                                     = 626
	TSqlParserOFFSET                                      = 627
	TSqlParserOLD_ACCOUNT                                 = 628
	TSqlParserONLINE                                      = 629
	TSqlParserONLY                                        = 630
	TSqlParserOPEN_EXISTING                               = 631
	TSqlParserOPTIMISTIC                                  = 632
	TSqlParserOPTIMIZE                                    = 633
	TSqlParserOUT                                         = 634
	TSqlParserOUTPUT                                      = 635
	TSqlParserOWNER                                       = 636
	TSqlParserPAGE_VERIFY                                 = 637
	TSqlParserPARAMETERIZATION                            = 638
	TSqlParserPARTITION                                   = 639
	TSqlParserPARTITIONS                                  = 640
	TSqlParserPARTNER                                     = 641
	TSqlParserPATH                                        = 642
	TSqlParserPOISON_MESSAGE_HANDLING                     = 643
	TSqlParserPOOL                                        = 644
	TSqlParserPORT                                        = 645
	TSqlParserPRECEDING                                   = 646
	TSqlParserPRIMARY_ROLE                                = 647
	TSqlParserPRIOR                                       = 648
	TSqlParserPRIORITY                                    = 649
	TSqlParserPRIORITY_LEVEL                              = 650
	TSqlParserPRIVATE                                     = 651
	TSqlParserPRIVATE_KEY                                 = 652
	TSqlParserPRIVILEGES                                  = 653
	TSqlParserPROCEDURE_NAME                              = 654
	TSqlParserPROPERTY                                    = 655
	TSqlParserPROVIDER                                    = 656
	TSqlParserPROVIDER_KEY_NAME                           = 657
	TSqlParserQUERY                                       = 658
	TSqlParserQUEUE                                       = 659
	TSqlParserQUEUE_DELAY                                 = 660
	TSqlParserQUOTED_IDENTIFIER                           = 661
	TSqlParserRANGE                                       = 662
	TSqlParserRANK                                        = 663
	TSqlParserRC2                                         = 664
	TSqlParserRC4                                         = 665
	TSqlParserRC4_128                                     = 666
	TSqlParserREAD_COMMITTED_SNAPSHOT                     = 667
	TSqlParserREAD_ONLY                                   = 668
	TSqlParserREAD_ONLY_ROUTING_LIST                      = 669
	TSqlParserREAD_WRITE                                  = 670
	TSqlParserREADONLY                                    = 671
	TSqlParserREBUILD                                     = 672
	TSqlParserRECEIVE                                     = 673
	TSqlParserRECOMPILE                                   = 674
	TSqlParserRECOVERY                                    = 675
	TSqlParserRECURSIVE_TRIGGERS                          = 676
	TSqlParserRELATIVE                                    = 677
	TSqlParserREMOTE                                      = 678
	TSqlParserREMOTE_SERVICE_NAME                         = 679
	TSqlParserREMOVE                                      = 680
	TSqlParserREORGANIZE                                  = 681
	TSqlParserREPEATABLE                                  = 682
	TSqlParserREPLICA                                     = 683
	TSqlParserREQUEST_MAX_CPU_TIME_SEC                    = 684
	TSqlParserREQUEST_MAX_MEMORY_GRANT_PERCENT            = 685
	TSqlParserREQUEST_MEMORY_GRANT_TIMEOUT_SEC            = 686
	TSqlParserREQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT = 687
	TSqlParserRESERVE_DISK_SPACE                          = 688
	TSqlParserRESOURCE                                    = 689
	TSqlParserRESOURCE_MANAGER_LOCATION                   = 690
	TSqlParserRESTRICTED_USER                             = 691
	TSqlParserRETENTION                                   = 692
	TSqlParserROBUST                                      = 693
	TSqlParserROOT                                        = 694
	TSqlParserROUTE                                       = 695
	TSqlParserROW                                         = 696
	TSqlParserROW_NUMBER                                  = 697
	TSqlParserROWGUID                                     = 698
	TSqlParserROWS                                        = 699
	TSqlParserSAMPLE                                      = 700
	TSqlParserSCHEMABINDING                               = 701
	TSqlParserSCOPED                                      = 702
	TSqlParserSCROLL                                      = 703
	TSqlParserSCROLL_LOCKS                                = 704
	TSqlParserSEARCH                                      = 705
	TSqlParserSECONDARY                                   = 706
	TSqlParserSECONDARY_ONLY                              = 707
	TSqlParserSECONDARY_ROLE                              = 708
	TSqlParserSECONDS                                     = 709
	TSqlParserSECRET                                      = 710
	TSqlParserSECURITY_LOG                                = 711
	TSqlParserSEEDING_MODE                                = 712
	TSqlParserSELF                                        = 713
	TSqlParserSEMI_SENSITIVE                              = 714
	TSqlParserSEND                                        = 715
	TSqlParserSENT                                        = 716
	TSqlParserSERIALIZABLE                                = 717
	TSqlParserSESSION_TIMEOUT                             = 718
	TSqlParserSETERROR                                    = 719
	TSqlParserSHARE                                       = 720
	TSqlParserSHOWPLAN                                    = 721
	TSqlParserSIGNATURE                                   = 722
	TSqlParserSIMPLE                                      = 723
	TSqlParserSINGLE_USER                                 = 724
	TSqlParserSIZE                                        = 725
	TSqlParserSMALLINT                                    = 726
	TSqlParserSNAPSHOT                                    = 727
	TSqlParserSPATIAL_WINDOW_MAX_CELLS                    = 728
	TSqlParserSTANDBY                                     = 729
	TSqlParserSTART_DATE                                  = 730
	TSqlParserSTATIC                                      = 731
	TSqlParserSTATS_STREAM                                = 732
	TSqlParserSTATUS                                      = 733
	TSqlParserSTDEV                                       = 734
	TSqlParserSTDEVP                                      = 735
	TSqlParserSTOPLIST                                    = 736
	TSqlParserSTUFF                                       = 737
	TSqlParserSUBJECT                                     = 738
	TSqlParserSUM                                         = 739
	TSqlParserSUSPEND                                     = 740
	TSqlParserSYMMETRIC                                   = 741
	TSqlParserSYNCHRONOUS_COMMIT                          = 742
	TSqlParserSYNONYM                                     = 743
	TSqlParserTAKE                                        = 744
	TSqlParserTARGET_RECOVERY_TIME                        = 745
	TSqlParserTB                                          = 746
	TSqlParserTEXTIMAGE_ON                                = 747
	TSqlParserTHROW                                       = 748
	TSqlParserTIES                                        = 749
	TSqlParserTIME                                        = 750
	TSqlParserTIMEOUT                                     = 751
	TSqlParserTIMER                                       = 752
	TSqlParserTINYINT                                     = 753
	TSqlParserTORN_PAGE_DETECTION                         = 754
	TSqlParserTRANSFORM_NOISE_WORDS                       = 755
	TSqlParserTRIPLE_DES                                  = 756
	TSqlParserTRIPLE_DES_3KEY                             = 757
	TSqlParserTRUSTWORTHY                                 = 758
	TSqlParserTRY                                         = 759
	TSqlParserTSQL                                        = 760
	TSqlParserTWO_DIGIT_YEAR_CUTOFF                       = 761
	TSqlParserTYPE                                        = 762
	TSqlParserTYPE_WARNING                                = 763
	TSqlParserUNBOUNDED                                   = 764
	TSqlParserUNCOMMITTED                                 = 765
	TSqlParserUNKNOWN                                     = 766
	TSqlParserUNLIMITED                                   = 767
	TSqlParserUSING                                       = 768
	TSqlParserVALID_XML                                   = 769
	TSqlParserVALIDATION                                  = 770
	TSqlParserVALUE                                       = 771
	TSqlParserVAR                                         = 772
	TSqlParserVARP                                        = 773
	TSqlParserVIEW_METADATA                               = 774
	TSqlParserVIEWS                                       = 775
	TSqlParserWAIT                                        = 776
	TSqlParserWELL_FORMED_XML                             = 777
	TSqlParserWITHOUT_ARRAY_WRAPPER                       = 778
	TSqlParserWORK                                        = 779
	TSqlParserWORKLOAD                                    = 780
	TSqlParserXML                                         = 781
	TSqlParserXMLDATA                                     = 782
	TSqlParserXMLNAMESPACES                               = 783
	TSqlParserXMLSCHEMA                                   = 784
	TSqlParserXSINIL                                      = 785
	TSqlParserDOLLAR_ACTION                               = 786
	TSqlParserSPACE                                       = 787
	TSqlParserCOMMENT                                     = 788
	TSqlParserLINE_COMMENT                                = 789
	TSqlParserDOUBLE_QUOTE_ID                             = 790
	TSqlParserSINGLE_QUOTE                                = 791
	TSqlParserSQUARE_BRACKET_ID                           = 792
	TSqlParserLOCAL_ID                                    = 793
	TSqlParserDECIMAL                                     = 794
	TSqlParserID                                          = 795
	TSqlParserQUOTED_URL                                  = 796
	TSqlParserQUOTED_HOST_AND_PORT                        = 797
	TSqlParserSTRING                                      = 798
	TSqlParserBINARY                                      = 799
	TSqlParserFLOAT                                       = 800
	TSqlParserREAL                                        = 801
	TSqlParserEQUAL                                       = 802
	TSqlParserGREATER                                     = 803
	TSqlParserLESS                                        = 804
	TSqlParserEXCLAMATION                                 = 805
	TSqlParserPLUS_ASSIGN                                 = 806
	TSqlParserMINUS_ASSIGN                                = 807
	TSqlParserMULT_ASSIGN                                 = 808
	TSqlParserDIV_ASSIGN                                  = 809
	TSqlParserMOD_ASSIGN                                  = 810
	TSqlParserAND_ASSIGN                                  = 811
	TSqlParserXOR_ASSIGN                                  = 812
	TSqlParserOR_ASSIGN                                   = 813
	TSqlParserDOUBLE_BAR                                  = 814
	TSqlParserDOT                                         = 815
	TSqlParserUNDERLINE                                   = 816
	TSqlParserAT                                          = 817
	TSqlParserSHARP                                       = 818
	TSqlParserDOLLAR                                      = 819
	TSqlParserLR_BRACKET                                  = 820
	TSqlParserRR_BRACKET                                  = 821
	TSqlParserCOMMA                                       = 822
	TSqlParserSEMI                                        = 823
	TSqlParserCOLON                                       = 824
	TSqlParserSTAR                                        = 825
	TSqlParserDIVIDE                                      = 826
	TSqlParserMODULE                                      = 827
	TSqlParserPLUS                                        = 828
	TSqlParserMINUS                                       = 829
	TSqlParserBIT_NOT                                     = 830
	TSqlParserBIT_OR                                      = 831
	TSqlParserBIT_AND                                     = 832
	TSqlParserBIT_XOR                                     = 833
	TSqlParserIPV4_OCTECT                                 = 834
)

TSqlParser tokens.

View Source
const (
	TSqlParserRULE_tsql_file                               = 0
	TSqlParserRULE_batch                                   = 1
	TSqlParserRULE_sql_clauses                             = 2
	TSqlParserRULE_sql_clause                              = 3
	TSqlParserRULE_dml_clause                              = 4
	TSqlParserRULE_ddl_clause                              = 5
	TSqlParserRULE_backup_statement                        = 6
	TSqlParserRULE_cfl_statement                           = 7
	TSqlParserRULE_block_statement                         = 8
	TSqlParserRULE_break_statement                         = 9
	TSqlParserRULE_continue_statement                      = 10
	TSqlParserRULE_goto_statement                          = 11
	TSqlParserRULE_return_statement                        = 12
	TSqlParserRULE_if_statement                            = 13
	TSqlParserRULE_throw_statement                         = 14
	TSqlParserRULE_throw_error_number                      = 15
	TSqlParserRULE_throw_message                           = 16
	TSqlParserRULE_throw_state                             = 17
	TSqlParserRULE_try_catch_statement                     = 18
	TSqlParserRULE_waitfor_statement                       = 19
	TSqlParserRULE_while_statement                         = 20
	TSqlParserRULE_print_statement                         = 21
	TSqlParserRULE_raiseerror_statement                    = 22
	TSqlParserRULE_empty_statement                         = 23
	TSqlParserRULE_another_statement                       = 24
	TSqlParserRULE_alter_application_role                  = 25
	TSqlParserRULE_create_application_role                 = 26
	TSqlParserRULE_drop_aggregate                          = 27
	TSqlParserRULE_drop_application_role                   = 28
	TSqlParserRULE_alter_assembly                          = 29
	TSqlParserRULE_alter_assembly_start                    = 30
	TSqlParserRULE_alter_assembly_clause                   = 31
	TSqlParserRULE_alter_assembly_from_clause              = 32
	TSqlParserRULE_alter_assembly_from_clause_start        = 33
	TSqlParserRULE_alter_assembly_drop_clause              = 34
	TSqlParserRULE_alter_assembly_drop_multiple_files      = 35
	TSqlParserRULE_alter_assembly_drop                     = 36
	TSqlParserRULE_alter_assembly_add_clause               = 37
	TSqlParserRULE_alter_asssembly_add_clause_start        = 38
	TSqlParserRULE_alter_assembly_client_file_clause       = 39
	TSqlParserRULE_alter_assembly_file_name                = 40
	TSqlParserRULE_alter_assembly_file_bits                = 41
	TSqlParserRULE_alter_assembly_as                       = 42
	TSqlParserRULE_alter_assembly_with_clause              = 43
	TSqlParserRULE_alter_assembly_with                     = 44
	TSqlParserRULE_client_assembly_specifier               = 45
	TSqlParserRULE_assembly_option                         = 46
	TSqlParserRULE_network_file_share                      = 47
	TSqlParserRULE_network_computer                        = 48
	TSqlParserRULE_network_file_start                      = 49
	TSqlParserRULE_file_path                               = 50
	TSqlParserRULE_file_directory_path_separator           = 51
	TSqlParserRULE_local_file                              = 52
	TSqlParserRULE_local_drive                             = 53
	TSqlParserRULE_multiple_local_files                    = 54
	TSqlParserRULE_multiple_local_file_start               = 55
	TSqlParserRULE_create_assembly                         = 56
	TSqlParserRULE_drop_assembly                           = 57
	TSqlParserRULE_alter_asymmetric_key                    = 58
	TSqlParserRULE_alter_asymmetric_key_start              = 59
	TSqlParserRULE_asymmetric_key_option                   = 60
	TSqlParserRULE_asymmetric_key_option_start             = 61
	TSqlParserRULE_asymmetric_key_password_change_option   = 62
	TSqlParserRULE_create_asymmetric_key                   = 63
	TSqlParserRULE_drop_asymmetric_key                     = 64
	TSqlParserRULE_alter_authorization                     = 65
	TSqlParserRULE_authorization_grantee                   = 66
	TSqlParserRULE_entity_to                               = 67
	TSqlParserRULE_colon_colon                             = 68
	TSqlParserRULE_alter_authorization_start               = 69
	TSqlParserRULE_alter_authorization_for_sql_database    = 70
	TSqlParserRULE_alter_authorization_for_azure_dw        = 71
	TSqlParserRULE_alter_authorization_for_parallel_dw     = 72
	TSqlParserRULE_class_type                              = 73
	TSqlParserRULE_class_type_for_sql_database             = 74
	TSqlParserRULE_class_type_for_azure_dw                 = 75
	TSqlParserRULE_class_type_for_parallel_dw              = 76
	TSqlParserRULE_drop_availability_group                 = 77
	TSqlParserRULE_alter_availability_group                = 78
	TSqlParserRULE_alter_availability_group_start          = 79
	TSqlParserRULE_alter_availability_group_options        = 80
	TSqlParserRULE_create_or_alter_broker_priority         = 81
	TSqlParserRULE_drop_broker_priority                    = 82
	TSqlParserRULE_alter_certificate                       = 83
	TSqlParserRULE_alter_column_encryption_key             = 84
	TSqlParserRULE_create_column_encryption_key            = 85
	TSqlParserRULE_drop_certificate                        = 86
	TSqlParserRULE_drop_column_encryption_key              = 87
	TSqlParserRULE_drop_column_master_key                  = 88
	TSqlParserRULE_drop_contract                           = 89
	TSqlParserRULE_drop_credential                         = 90
	TSqlParserRULE_drop_cryptograhic_provider              = 91
	TSqlParserRULE_drop_database                           = 92
	TSqlParserRULE_drop_database_audit_specification       = 93
	TSqlParserRULE_drop_database_scoped_credential         = 94
	TSqlParserRULE_drop_default                            = 95
	TSqlParserRULE_drop_endpoint                           = 96
	TSqlParserRULE_drop_external_data_source               = 97
	TSqlParserRULE_drop_external_file_format               = 98
	TSqlParserRULE_drop_external_library                   = 99
	TSqlParserRULE_drop_external_resource_pool             = 100
	TSqlParserRULE_drop_external_table                     = 101
	TSqlParserRULE_drop_event_notifications                = 102
	TSqlParserRULE_drop_event_session                      = 103
	TSqlParserRULE_drop_fulltext_catalog                   = 104
	TSqlParserRULE_drop_fulltext_index                     = 105
	TSqlParserRULE_drop_fulltext_stoplist                  = 106
	TSqlParserRULE_drop_login                              = 107
	TSqlParserRULE_drop_master_key                         = 108
	TSqlParserRULE_drop_message_type                       = 109
	TSqlParserRULE_drop_partition_function                 = 110
	TSqlParserRULE_drop_partition_scheme                   = 111
	TSqlParserRULE_drop_queue                              = 112
	TSqlParserRULE_drop_remote_service_binding             = 113
	TSqlParserRULE_drop_resource_pool                      = 114
	TSqlParserRULE_drop_db_role                            = 115
	TSqlParserRULE_drop_route                              = 116
	TSqlParserRULE_drop_rule                               = 117
	TSqlParserRULE_drop_schema                             = 118
	TSqlParserRULE_drop_search_property_list               = 119
	TSqlParserRULE_drop_security_policy                    = 120
	TSqlParserRULE_drop_sequence                           = 121
	TSqlParserRULE_drop_server_audit                       = 122
	TSqlParserRULE_drop_server_audit_specification         = 123
	TSqlParserRULE_drop_server_role                        = 124
	TSqlParserRULE_drop_service                            = 125
	TSqlParserRULE_drop_signature                          = 126
	TSqlParserRULE_drop_statistics_name_azure_dw_and_pdw   = 127
	TSqlParserRULE_drop_symmetric_key                      = 128
	TSqlParserRULE_drop_synonym                            = 129
	TSqlParserRULE_drop_user                               = 130
	TSqlParserRULE_drop_workload_group                     = 131
	TSqlParserRULE_drop_xml_schema_collection              = 132
	TSqlParserRULE_disable_trigger                         = 133
	TSqlParserRULE_enable_trigger                          = 134
	TSqlParserRULE_lock_table                              = 135
	TSqlParserRULE_truncate_table                          = 136
	TSqlParserRULE_create_column_master_key                = 137
	TSqlParserRULE_alter_credential                        = 138
	TSqlParserRULE_create_credential                       = 139
	TSqlParserRULE_alter_cryptographic_provider            = 140
	TSqlParserRULE_create_cryptographic_provider           = 141
	TSqlParserRULE_create_event_notification               = 142
	TSqlParserRULE_create_or_alter_event_session           = 143
	TSqlParserRULE_event_session_predicate_expression      = 144
	TSqlParserRULE_event_session_predicate_factor          = 145
	TSqlParserRULE_event_session_predicate_leaf            = 146
	TSqlParserRULE_alter_external_data_source              = 147
	TSqlParserRULE_alter_external_library                  = 148
	TSqlParserRULE_create_external_library                 = 149
	TSqlParserRULE_alter_external_resource_pool            = 150
	TSqlParserRULE_create_external_resource_pool           = 151
	TSqlParserRULE_alter_fulltext_catalog                  = 152
	TSqlParserRULE_create_fulltext_catalog                 = 153
	TSqlParserRULE_alter_fulltext_stoplist                 = 154
	TSqlParserRULE_create_fulltext_stoplist                = 155
	TSqlParserRULE_alter_login_sql_server                  = 156
	TSqlParserRULE_create_login_sql_server                 = 157
	TSqlParserRULE_alter_login_azure_sql                   = 158
	TSqlParserRULE_create_login_azure_sql                  = 159
	TSqlParserRULE_alter_login_azure_sql_dw_and_pdw        = 160
	TSqlParserRULE_create_login_pdw                        = 161
	TSqlParserRULE_alter_master_key_sql_server             = 162
	TSqlParserRULE_create_master_key_sql_server            = 163
	TSqlParserRULE_alter_master_key_azure_sql              = 164
	TSqlParserRULE_create_master_key_azure_sql             = 165
	TSqlParserRULE_alter_message_type                      = 166
	TSqlParserRULE_alter_partition_function                = 167
	TSqlParserRULE_alter_partition_scheme                  = 168
	TSqlParserRULE_alter_remote_service_binding            = 169
	TSqlParserRULE_create_remote_service_binding           = 170
	TSqlParserRULE_create_resource_pool                    = 171
	TSqlParserRULE_alter_resource_governor                 = 172
	TSqlParserRULE_alter_db_role                           = 173
	TSqlParserRULE_create_db_role                          = 174
	TSqlParserRULE_create_route                            = 175
	TSqlParserRULE_create_rule                             = 176
	TSqlParserRULE_alter_schema_sql                        = 177
	TSqlParserRULE_create_schema                           = 178
	TSqlParserRULE_create_schema_azure_sql_dw_and_pdw      = 179
	TSqlParserRULE_alter_schema_azure_sql_dw_and_pdw       = 180
	TSqlParserRULE_create_search_property_list             = 181
	TSqlParserRULE_create_security_policy                  = 182
	TSqlParserRULE_alter_sequence                          = 183
	TSqlParserRULE_create_sequence                         = 184
	TSqlParserRULE_alter_server_audit                      = 185
	TSqlParserRULE_create_server_audit                     = 186
	TSqlParserRULE_alter_server_audit_specification        = 187
	TSqlParserRULE_create_server_audit_specification       = 188
	TSqlParserRULE_alter_server_configuration              = 189
	TSqlParserRULE_alter_server_role                       = 190
	TSqlParserRULE_create_server_role                      = 191
	TSqlParserRULE_alter_server_role_pdw                   = 192
	TSqlParserRULE_alter_service                           = 193
	TSqlParserRULE_create_service                          = 194
	TSqlParserRULE_alter_service_master_key                = 195
	TSqlParserRULE_alter_symmetric_key                     = 196
	TSqlParserRULE_create_symmetric_key                    = 197
	TSqlParserRULE_create_synonym                          = 198
	TSqlParserRULE_alter_user                              = 199
	TSqlParserRULE_create_user                             = 200
	TSqlParserRULE_create_user_azure_sql_dw                = 201
	TSqlParserRULE_alter_user_azure_sql                    = 202
	TSqlParserRULE_alter_workload_group                    = 203
	TSqlParserRULE_create_workload_group                   = 204
	TSqlParserRULE_create_xml_schema_collection            = 205
	TSqlParserRULE_create_queue                            = 206
	TSqlParserRULE_queue_settings                          = 207
	TSqlParserRULE_alter_queue                             = 208
	TSqlParserRULE_queue_action                            = 209
	TSqlParserRULE_queue_rebuild_options                   = 210
	TSqlParserRULE_create_contract                         = 211
	TSqlParserRULE_conversation_statement                  = 212
	TSqlParserRULE_message_statement                       = 213
	TSqlParserRULE_merge_statement                         = 214
	TSqlParserRULE_merge_matched                           = 215
	TSqlParserRULE_merge_not_matched                       = 216
	TSqlParserRULE_delete_statement                        = 217
	TSqlParserRULE_delete_statement_from                   = 218
	TSqlParserRULE_insert_statement                        = 219
	TSqlParserRULE_insert_statement_value                  = 220
	TSqlParserRULE_receive_statement                       = 221
	TSqlParserRULE_select_statement                        = 222
	TSqlParserRULE_time                                    = 223
	TSqlParserRULE_update_statement                        = 224
	TSqlParserRULE_output_clause                           = 225
	TSqlParserRULE_output_dml_list_elem                    = 226
	TSqlParserRULE_output_column_name                      = 227
	TSqlParserRULE_create_database                         = 228
	TSqlParserRULE_create_index                            = 229
	TSqlParserRULE_create_or_alter_procedure               = 230
	TSqlParserRULE_create_or_alter_trigger                 = 231
	TSqlParserRULE_create_or_alter_dml_trigger             = 232
	TSqlParserRULE_dml_trigger_option                      = 233
	TSqlParserRULE_dml_trigger_operation                   = 234
	TSqlParserRULE_create_or_alter_ddl_trigger             = 235
	TSqlParserRULE_ddl_trigger_operation                   = 236
	TSqlParserRULE_create_or_alter_function                = 237
	TSqlParserRULE_func_body_returns_select                = 238
	TSqlParserRULE_func_body_returns_table                 = 239
	TSqlParserRULE_func_body_returns_scalar                = 240
	TSqlParserRULE_procedure_param                         = 241
	TSqlParserRULE_procedure_option                        = 242
	TSqlParserRULE_function_option                         = 243
	TSqlParserRULE_create_statistics                       = 244
	TSqlParserRULE_update_statistics                       = 245
	TSqlParserRULE_create_table                            = 246
	TSqlParserRULE_table_options                           = 247
	TSqlParserRULE_create_view                             = 248
	TSqlParserRULE_view_attribute                          = 249
	TSqlParserRULE_alter_table                             = 250
	TSqlParserRULE_alter_database                          = 251
	TSqlParserRULE_database_optionspec                     = 252
	TSqlParserRULE_auto_option                             = 253
	TSqlParserRULE_change_tracking_option                  = 254
	TSqlParserRULE_change_tracking_option_list             = 255
	TSqlParserRULE_containment_option                      = 256
	TSqlParserRULE_cursor_option                           = 257
	TSqlParserRULE_alter_endpoint                          = 258
	TSqlParserRULE_database_mirroring_option               = 259
	TSqlParserRULE_mirroring_set_option                    = 260
	TSqlParserRULE_mirroring_partner                       = 261
	TSqlParserRULE_mirroring_witness                       = 262
	TSqlParserRULE_witness_partner_equal                   = 263
	TSqlParserRULE_partner_option                          = 264
	TSqlParserRULE_witness_option                          = 265
	TSqlParserRULE_witness_server                          = 266
	TSqlParserRULE_partner_server                          = 267
	TSqlParserRULE_mirroring_host_port_seperator           = 268
	TSqlParserRULE_partner_server_tcp_prefix               = 269
	TSqlParserRULE_port_number                             = 270
	TSqlParserRULE_host                                    = 271
	TSqlParserRULE_date_correlation_optimization_option    = 272
	TSqlParserRULE_db_encryption_option                    = 273
	TSqlParserRULE_db_state_option                         = 274
	TSqlParserRULE_db_update_option                        = 275
	TSqlParserRULE_db_user_access_option                   = 276
	TSqlParserRULE_delayed_durability_option               = 277
	TSqlParserRULE_external_access_option                  = 278
	TSqlParserRULE_hadr_options                            = 279
	TSqlParserRULE_mixed_page_allocation_option            = 280
	TSqlParserRULE_parameterization_option                 = 281
	TSqlParserRULE_recovery_option                         = 282
	TSqlParserRULE_service_broker_option                   = 283
	TSqlParserRULE_snapshot_option                         = 284
	TSqlParserRULE_sql_option                              = 285
	TSqlParserRULE_target_recovery_time_option             = 286
	TSqlParserRULE_termination                             = 287
	TSqlParserRULE_drop_index                              = 288
	TSqlParserRULE_drop_relational_or_xml_or_spatial_index = 289
	TSqlParserRULE_drop_backward_compatible_index          = 290
	TSqlParserRULE_drop_procedure                          = 291
	TSqlParserRULE_drop_trigger                            = 292
	TSqlParserRULE_drop_dml_trigger                        = 293
	TSqlParserRULE_drop_ddl_trigger                        = 294
	TSqlParserRULE_drop_function                           = 295
	TSqlParserRULE_drop_statistics                         = 296
	TSqlParserRULE_drop_table                              = 297
	TSqlParserRULE_drop_view                               = 298
	TSqlParserRULE_create_type                             = 299
	TSqlParserRULE_drop_type                               = 300
	TSqlParserRULE_rowset_function_limited                 = 301
	TSqlParserRULE_openquery                               = 302
	TSqlParserRULE_opendatasource                          = 303
	TSqlParserRULE_declare_statement                       = 304
	TSqlParserRULE_cursor_statement                        = 305
	TSqlParserRULE_backup_database                         = 306
	TSqlParserRULE_backup_log                              = 307
	TSqlParserRULE_backup_certificate                      = 308
	TSqlParserRULE_backup_master_key                       = 309
	TSqlParserRULE_backup_service_master_key               = 310
	TSqlParserRULE_execute_statement                       = 311
	TSqlParserRULE_execute_body                            = 312
	TSqlParserRULE_execute_statement_arg                   = 313
	TSqlParserRULE_execute_var_string                      = 314
	TSqlParserRULE_security_statement                      = 315
	TSqlParserRULE_create_certificate                      = 316
	TSqlParserRULE_existing_keys                           = 317
	TSqlParserRULE_private_key_options                     = 318
	TSqlParserRULE_generate_new_keys                       = 319
	TSqlParserRULE_date_options                            = 320
	TSqlParserRULE_open_key                                = 321
	TSqlParserRULE_close_key                               = 322
	TSqlParserRULE_create_key                              = 323
	TSqlParserRULE_key_options                             = 324
	TSqlParserRULE_algorithm                               = 325
	TSqlParserRULE_encryption_mechanism                    = 326
	TSqlParserRULE_decryption_mechanism                    = 327
	TSqlParserRULE_grant_permission                        = 328
	TSqlParserRULE_set_statement                           = 329
	TSqlParserRULE_transaction_statement                   = 330
	TSqlParserRULE_go_statement                            = 331
	TSqlParserRULE_use_statement                           = 332
	TSqlParserRULE_setuser_statement                       = 333
	TSqlParserRULE_dbcc_clause                             = 334
	TSqlParserRULE_dbcc_options                            = 335
	TSqlParserRULE_execute_clause                          = 336
	TSqlParserRULE_declare_local                           = 337
	TSqlParserRULE_table_type_definition                   = 338
	TSqlParserRULE_xml_type_definition                     = 339
	TSqlParserRULE_xml_schema_collection                   = 340
	TSqlParserRULE_column_def_table_constraints            = 341
	TSqlParserRULE_column_def_table_constraint             = 342
	TSqlParserRULE_column_definition                       = 343
	TSqlParserRULE_materialized_column_definition          = 344
	TSqlParserRULE_column_constraint                       = 345
	TSqlParserRULE_table_constraint                        = 346
	TSqlParserRULE_on_delete                               = 347
	TSqlParserRULE_on_update                               = 348
	TSqlParserRULE_index_options                           = 349
	TSqlParserRULE_index_option                            = 350
	TSqlParserRULE_declare_cursor                          = 351
	TSqlParserRULE_declare_set_cursor_common               = 352
	TSqlParserRULE_declare_set_cursor_common_partial       = 353
	TSqlParserRULE_fetch_cursor                            = 354
	TSqlParserRULE_set_special                             = 355
	TSqlParserRULE_constant_LOCAL_ID                       = 356
	TSqlParserRULE_expression                              = 357
	TSqlParserRULE_primitive_expression                    = 358
	TSqlParserRULE_case_expression                         = 359
	TSqlParserRULE_unary_operator_expression               = 360
	TSqlParserRULE_bracket_expression                      = 361
	TSqlParserRULE_constant_expression                     = 362
	TSqlParserRULE_subquery                                = 363
	TSqlParserRULE_with_expression                         = 364
	TSqlParserRULE_common_table_expression                 = 365
	TSqlParserRULE_update_elem                             = 366
	TSqlParserRULE_search_condition_list                   = 367
	TSqlParserRULE_search_condition                        = 368
	TSqlParserRULE_search_condition_and                    = 369
	TSqlParserRULE_search_condition_not                    = 370
	TSqlParserRULE_predicate                               = 371
	TSqlParserRULE_query_expression                        = 372
	TSqlParserRULE_sql_union                               = 373
	TSqlParserRULE_query_specification                     = 374
	TSqlParserRULE_top_clause                              = 375
	TSqlParserRULE_top_percent                             = 376
	TSqlParserRULE_top_count                               = 377
	TSqlParserRULE_order_by_clause                         = 378
	TSqlParserRULE_for_clause                              = 379
	TSqlParserRULE_xml_common_directives                   = 380
	TSqlParserRULE_order_by_expression                     = 381
	TSqlParserRULE_group_by_item                           = 382
	TSqlParserRULE_option_clause                           = 383
	TSqlParserRULE_option                                  = 384
	TSqlParserRULE_optimize_for_arg                        = 385
	TSqlParserRULE_select_list                             = 386
	TSqlParserRULE_udt_method_arguments                    = 387
	TSqlParserRULE_asterisk                                = 388
	TSqlParserRULE_column_elem                             = 389
	TSqlParserRULE_udt_elem                                = 390
	TSqlParserRULE_expression_elem                         = 391
	TSqlParserRULE_select_list_elem                        = 392
	TSqlParserRULE_table_sources                           = 393
	TSqlParserRULE_table_source                            = 394
	TSqlParserRULE_table_source_item_joined                = 395
	TSqlParserRULE_table_source_item                       = 396
	TSqlParserRULE_open_xml                                = 397
	TSqlParserRULE_schema_declaration                      = 398
	TSqlParserRULE_column_declaration                      = 399
	TSqlParserRULE_change_table                            = 400
	TSqlParserRULE_join_part                               = 401
	TSqlParserRULE_pivot_clause                            = 402
	TSqlParserRULE_unpivot_clause                          = 403
	TSqlParserRULE_full_column_name_list                   = 404
	TSqlParserRULE_table_name_with_hint                    = 405
	TSqlParserRULE_rowset_function                         = 406
	TSqlParserRULE_bulk_option                             = 407
	TSqlParserRULE_derived_table                           = 408
	TSqlParserRULE_function_call                           = 409
	TSqlParserRULE_xml_data_type_methods                   = 410
	TSqlParserRULE_value_method                            = 411
	TSqlParserRULE_query_method                            = 412
	TSqlParserRULE_exist_method                            = 413
	TSqlParserRULE_modify_method                           = 414
	TSqlParserRULE_nodes_method                            = 415
	TSqlParserRULE_switch_section                          = 416
	TSqlParserRULE_switch_search_condition_section         = 417
	TSqlParserRULE_as_column_alias                         = 418
	TSqlParserRULE_as_table_alias                          = 419
	TSqlParserRULE_table_alias                             = 420
	TSqlParserRULE_with_table_hints                        = 421
	TSqlParserRULE_insert_with_table_hints                 = 422
	TSqlParserRULE_table_hint                              = 423
	TSqlParserRULE_index_value                             = 424
	TSqlParserRULE_column_alias_list                       = 425
	TSqlParserRULE_column_alias                            = 426
	TSqlParserRULE_table_value_constructor                 = 427
	TSqlParserRULE_expression_list                         = 428
	TSqlParserRULE_ranking_windowed_function               = 429
	TSqlParserRULE_aggregate_windowed_function             = 430
	TSqlParserRULE_analytic_windowed_function              = 431
	TSqlParserRULE_all_distinct_expression                 = 432
	TSqlParserRULE_over_clause                             = 433
	TSqlParserRULE_row_or_range_clause                     = 434
	TSqlParserRULE_window_frame_extent                     = 435
	TSqlParserRULE_window_frame_bound                      = 436
	TSqlParserRULE_window_frame_preceding                  = 437
	TSqlParserRULE_window_frame_following                  = 438
	TSqlParserRULE_create_database_option                  = 439
	TSqlParserRULE_database_filestream_option              = 440
	TSqlParserRULE_database_file_spec                      = 441
	TSqlParserRULE_file_group                              = 442
	TSqlParserRULE_file_spec                               = 443
	TSqlParserRULE_entity_name                             = 444
	TSqlParserRULE_entity_name_for_azure_dw                = 445
	TSqlParserRULE_entity_name_for_parallel_dw             = 446
	TSqlParserRULE_full_table_name                         = 447
	TSqlParserRULE_table_name                              = 448
	TSqlParserRULE_simple_name                             = 449
	TSqlParserRULE_func_proc_name_schema                   = 450
	TSqlParserRULE_func_proc_name_database_schema          = 451
	TSqlParserRULE_func_proc_name_server_database_schema   = 452
	TSqlParserRULE_ddl_object                              = 453
	TSqlParserRULE_full_column_name                        = 454
	TSqlParserRULE_column_name_list_with_order             = 455
	TSqlParserRULE_column_name_list                        = 456
	TSqlParserRULE_cursor_name                             = 457
	TSqlParserRULE_on_off                                  = 458
	TSqlParserRULE_clustered                               = 459
	TSqlParserRULE_null_notnull                            = 460
	TSqlParserRULE_null_or_default                         = 461
	TSqlParserRULE_scalar_function_name                    = 462
	TSqlParserRULE_begin_conversation_timer                = 463
	TSqlParserRULE_begin_conversation_dialog               = 464
	TSqlParserRULE_contract_name                           = 465
	TSqlParserRULE_service_name                            = 466
	TSqlParserRULE_end_conversation                        = 467
	TSqlParserRULE_waitfor_conversation                    = 468
	TSqlParserRULE_get_conversation                        = 469
	TSqlParserRULE_queue_id                                = 470
	TSqlParserRULE_send_conversation                       = 471
	TSqlParserRULE_data_type                               = 472
	TSqlParserRULE_default_value                           = 473
	TSqlParserRULE_constant                                = 474
	TSqlParserRULE_sign                                    = 475
	TSqlParserRULE_id                                      = 476
	TSqlParserRULE_simple_id                               = 477
	TSqlParserRULE_comparison_operator                     = 478
	TSqlParserRULE_assignment_operator                     = 479
	TSqlParserRULE_file_size                               = 480
)

TSqlParser rules.

Variables

This section is empty.

Functions

This section is empty.

Types

type AGGREGATE_WINDOWED_FUNCContext

type AGGREGATE_WINDOWED_FUNCContext struct {
	*Function_callContext
}

func NewAGGREGATE_WINDOWED_FUNCContext

func NewAGGREGATE_WINDOWED_FUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AGGREGATE_WINDOWED_FUNCContext

func (*AGGREGATE_WINDOWED_FUNCContext) Aggregate_windowed_function

func (*AGGREGATE_WINDOWED_FUNCContext) EnterRule

func (*AGGREGATE_WINDOWED_FUNCContext) ExitRule

func (*AGGREGATE_WINDOWED_FUNCContext) GetRuleContext

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

type ANALYTIC_WINDOWED_FUNCContext

type ANALYTIC_WINDOWED_FUNCContext struct {
	*Function_callContext
}

func NewANALYTIC_WINDOWED_FUNCContext

func NewANALYTIC_WINDOWED_FUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ANALYTIC_WINDOWED_FUNCContext

func (*ANALYTIC_WINDOWED_FUNCContext) Analytic_windowed_function

func (s *ANALYTIC_WINDOWED_FUNCContext) Analytic_windowed_function() IAnalytic_windowed_functionContext

func (*ANALYTIC_WINDOWED_FUNCContext) EnterRule

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

func (*ANALYTIC_WINDOWED_FUNCContext) ExitRule

func (*ANALYTIC_WINDOWED_FUNCContext) GetRuleContext

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

type Aggregate_windowed_functionContext

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

func NewAggregate_windowed_functionContext

func NewAggregate_windowed_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_windowed_functionContext

func NewEmptyAggregate_windowed_functionContext

func NewEmptyAggregate_windowed_functionContext() *Aggregate_windowed_functionContext

func (*Aggregate_windowed_functionContext) AVG

func (*Aggregate_windowed_functionContext) All_distinct_expression

func (*Aggregate_windowed_functionContext) CHECKSUM_AGG

func (*Aggregate_windowed_functionContext) COUNT

func (*Aggregate_windowed_functionContext) COUNT_BIG

func (*Aggregate_windowed_functionContext) EnterRule

func (*Aggregate_windowed_functionContext) ExitRule

func (*Aggregate_windowed_functionContext) Expression

func (*Aggregate_windowed_functionContext) Expression_list

func (*Aggregate_windowed_functionContext) GROUPING

func (*Aggregate_windowed_functionContext) GROUPING_ID

func (*Aggregate_windowed_functionContext) GetParser

func (*Aggregate_windowed_functionContext) GetRuleContext

func (*Aggregate_windowed_functionContext) IsAggregate_windowed_functionContext

func (*Aggregate_windowed_functionContext) IsAggregate_windowed_functionContext()

func (*Aggregate_windowed_functionContext) LR_BRACKET

func (*Aggregate_windowed_functionContext) MAX

func (*Aggregate_windowed_functionContext) MIN

func (*Aggregate_windowed_functionContext) Over_clause

func (*Aggregate_windowed_functionContext) RR_BRACKET

func (*Aggregate_windowed_functionContext) STAR

func (*Aggregate_windowed_functionContext) STDEV

func (*Aggregate_windowed_functionContext) STDEVP

func (*Aggregate_windowed_functionContext) SUM

func (*Aggregate_windowed_functionContext) ToStringTree

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

func (*Aggregate_windowed_functionContext) VAR

func (*Aggregate_windowed_functionContext) VARP

type AlgorithmContext

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

func NewAlgorithmContext

func NewAlgorithmContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlgorithmContext

func NewEmptyAlgorithmContext

func NewEmptyAlgorithmContext() *AlgorithmContext

func (*AlgorithmContext) AES_128

func (s *AlgorithmContext) AES_128() antlr.TerminalNode

func (*AlgorithmContext) AES_192

func (s *AlgorithmContext) AES_192() antlr.TerminalNode

func (*AlgorithmContext) AES_256

func (s *AlgorithmContext) AES_256() antlr.TerminalNode

func (*AlgorithmContext) DES

func (*AlgorithmContext) DESX

func (*AlgorithmContext) EnterRule

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

func (*AlgorithmContext) ExitRule

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

func (*AlgorithmContext) GetParser

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

func (*AlgorithmContext) GetRuleContext

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

func (*AlgorithmContext) IsAlgorithmContext

func (*AlgorithmContext) IsAlgorithmContext()

func (*AlgorithmContext) RC2

func (*AlgorithmContext) RC4

func (*AlgorithmContext) RC4_128

func (s *AlgorithmContext) RC4_128() antlr.TerminalNode

func (*AlgorithmContext) TRIPLE_DES

func (s *AlgorithmContext) TRIPLE_DES() antlr.TerminalNode

func (*AlgorithmContext) TRIPLE_DES_3KEY

func (s *AlgorithmContext) TRIPLE_DES_3KEY() antlr.TerminalNode

func (*AlgorithmContext) ToStringTree

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

type All_distinct_expressionContext

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

func NewAll_distinct_expressionContext

func NewAll_distinct_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_distinct_expressionContext

func NewEmptyAll_distinct_expressionContext

func NewEmptyAll_distinct_expressionContext() *All_distinct_expressionContext

func (*All_distinct_expressionContext) ALL

func (*All_distinct_expressionContext) DISTINCT

func (*All_distinct_expressionContext) EnterRule

func (*All_distinct_expressionContext) ExitRule

func (*All_distinct_expressionContext) Expression

func (*All_distinct_expressionContext) GetParser

func (*All_distinct_expressionContext) GetRuleContext

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

func (*All_distinct_expressionContext) IsAll_distinct_expressionContext

func (*All_distinct_expressionContext) IsAll_distinct_expressionContext()

func (*All_distinct_expressionContext) ToStringTree

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

type Alter_application_roleContext

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

func NewAlter_application_roleContext

func NewAlter_application_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_application_roleContext

func NewEmptyAlter_application_roleContext

func NewEmptyAlter_application_roleContext() *Alter_application_roleContext

func (*Alter_application_roleContext) ALTER

func (*Alter_application_roleContext) APPLICATION

func (*Alter_application_roleContext) AllCOMMA

func (*Alter_application_roleContext) AllEQUAL

func (*Alter_application_roleContext) AllId

func (*Alter_application_roleContext) COMMA

func (*Alter_application_roleContext) DEFAULT_SCHEMA

func (s *Alter_application_roleContext) DEFAULT_SCHEMA() antlr.TerminalNode

func (*Alter_application_roleContext) EQUAL

func (*Alter_application_roleContext) EnterRule

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

func (*Alter_application_roleContext) ExitRule

func (*Alter_application_roleContext) GetApp_role_default_schema

func (s *Alter_application_roleContext) GetApp_role_default_schema() IIdContext

func (*Alter_application_roleContext) GetApplication_role_password

func (s *Alter_application_roleContext) GetApplication_role_password() antlr.Token

func (*Alter_application_roleContext) GetAppliction_role

func (s *Alter_application_roleContext) GetAppliction_role() IIdContext

func (*Alter_application_roleContext) GetNew_application_role_name

func (s *Alter_application_roleContext) GetNew_application_role_name() IIdContext

func (*Alter_application_roleContext) GetParser

func (*Alter_application_roleContext) GetRuleContext

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

func (*Alter_application_roleContext) Id

func (*Alter_application_roleContext) IsAlter_application_roleContext

func (*Alter_application_roleContext) IsAlter_application_roleContext()

func (*Alter_application_roleContext) NAME

func (*Alter_application_roleContext) PASSWORD

func (*Alter_application_roleContext) ROLE

func (*Alter_application_roleContext) STRING

func (*Alter_application_roleContext) SetApp_role_default_schema

func (s *Alter_application_roleContext) SetApp_role_default_schema(v IIdContext)

func (*Alter_application_roleContext) SetApplication_role_password

func (s *Alter_application_roleContext) SetApplication_role_password(v antlr.Token)

func (*Alter_application_roleContext) SetAppliction_role

func (s *Alter_application_roleContext) SetAppliction_role(v IIdContext)

func (*Alter_application_roleContext) SetNew_application_role_name

func (s *Alter_application_roleContext) SetNew_application_role_name(v IIdContext)

func (*Alter_application_roleContext) ToStringTree

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

func (*Alter_application_roleContext) WITH

type Alter_assemblyContext

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

func NewAlter_assemblyContext

func NewAlter_assemblyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assemblyContext

func NewEmptyAlter_assemblyContext

func NewEmptyAlter_assemblyContext() *Alter_assemblyContext

func (*Alter_assemblyContext) Alter_assembly_clause

func (s *Alter_assemblyContext) Alter_assembly_clause() IAlter_assembly_clauseContext

func (*Alter_assemblyContext) Alter_assembly_start

func (s *Alter_assemblyContext) Alter_assembly_start() IAlter_assembly_startContext

func (*Alter_assemblyContext) EnterRule

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

func (*Alter_assemblyContext) ExitRule

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

func (*Alter_assemblyContext) GetAssembly_name

func (s *Alter_assemblyContext) GetAssembly_name() IIdContext

func (*Alter_assemblyContext) GetParser

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

func (*Alter_assemblyContext) GetRuleContext

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

func (*Alter_assemblyContext) Id

func (*Alter_assemblyContext) IsAlter_assemblyContext

func (*Alter_assemblyContext) IsAlter_assemblyContext()

func (*Alter_assemblyContext) SetAssembly_name

func (s *Alter_assemblyContext) SetAssembly_name(v IIdContext)

func (*Alter_assemblyContext) ToStringTree

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

type Alter_assembly_add_clauseContext

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

func NewAlter_assembly_add_clauseContext

func NewAlter_assembly_add_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_add_clauseContext

func NewEmptyAlter_assembly_add_clauseContext

func NewEmptyAlter_assembly_add_clauseContext() *Alter_assembly_add_clauseContext

func (*Alter_assembly_add_clauseContext) Alter_assembly_client_file_clause

func (s *Alter_assembly_add_clauseContext) Alter_assembly_client_file_clause() IAlter_assembly_client_file_clauseContext

func (*Alter_assembly_add_clauseContext) Alter_asssembly_add_clause_start

func (s *Alter_assembly_add_clauseContext) Alter_asssembly_add_clause_start() IAlter_asssembly_add_clause_startContext

func (*Alter_assembly_add_clauseContext) EnterRule

func (*Alter_assembly_add_clauseContext) ExitRule

func (*Alter_assembly_add_clauseContext) GetParser

func (*Alter_assembly_add_clauseContext) GetRuleContext

func (*Alter_assembly_add_clauseContext) IsAlter_assembly_add_clauseContext

func (*Alter_assembly_add_clauseContext) IsAlter_assembly_add_clauseContext()

func (*Alter_assembly_add_clauseContext) ToStringTree

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

type Alter_assembly_asContext

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

func NewAlter_assembly_asContext

func NewAlter_assembly_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_asContext

func NewEmptyAlter_assembly_asContext

func NewEmptyAlter_assembly_asContext() *Alter_assembly_asContext

func (*Alter_assembly_asContext) AS

func (*Alter_assembly_asContext) EnterRule

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

func (*Alter_assembly_asContext) ExitRule

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

func (*Alter_assembly_asContext) GetParser

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

func (*Alter_assembly_asContext) GetRuleContext

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

func (*Alter_assembly_asContext) IsAlter_assembly_asContext

func (*Alter_assembly_asContext) IsAlter_assembly_asContext()

func (*Alter_assembly_asContext) ToStringTree

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

type Alter_assembly_clauseContext

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

func NewAlter_assembly_clauseContext

func NewAlter_assembly_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_clauseContext

func NewEmptyAlter_assembly_clauseContext

func NewEmptyAlter_assembly_clauseContext() *Alter_assembly_clauseContext

func (*Alter_assembly_clauseContext) Alter_assembly_add_clause

func (s *Alter_assembly_clauseContext) Alter_assembly_add_clause() IAlter_assembly_add_clauseContext

func (*Alter_assembly_clauseContext) Alter_assembly_drop_clause

func (s *Alter_assembly_clauseContext) Alter_assembly_drop_clause() IAlter_assembly_drop_clauseContext

func (*Alter_assembly_clauseContext) Alter_assembly_from_clause

func (s *Alter_assembly_clauseContext) Alter_assembly_from_clause() IAlter_assembly_from_clauseContext

func (*Alter_assembly_clauseContext) Alter_assembly_with_clause

func (s *Alter_assembly_clauseContext) Alter_assembly_with_clause() IAlter_assembly_with_clauseContext

func (*Alter_assembly_clauseContext) EnterRule

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

func (*Alter_assembly_clauseContext) ExitRule

func (*Alter_assembly_clauseContext) GetParser

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

func (*Alter_assembly_clauseContext) GetRuleContext

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

func (*Alter_assembly_clauseContext) IsAlter_assembly_clauseContext

func (*Alter_assembly_clauseContext) IsAlter_assembly_clauseContext()

func (*Alter_assembly_clauseContext) ToStringTree

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

type Alter_assembly_client_file_clauseContext

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

func NewAlter_assembly_client_file_clauseContext

func NewAlter_assembly_client_file_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_client_file_clauseContext

func NewEmptyAlter_assembly_client_file_clauseContext

func NewEmptyAlter_assembly_client_file_clauseContext() *Alter_assembly_client_file_clauseContext

func (*Alter_assembly_client_file_clauseContext) Alter_assembly_as

func (*Alter_assembly_client_file_clauseContext) Alter_assembly_file_name

func (*Alter_assembly_client_file_clauseContext) EnterRule

func (*Alter_assembly_client_file_clauseContext) ExitRule

func (*Alter_assembly_client_file_clauseContext) GetParser

func (*Alter_assembly_client_file_clauseContext) GetRuleContext

func (*Alter_assembly_client_file_clauseContext) Id

func (*Alter_assembly_client_file_clauseContext) IsAlter_assembly_client_file_clauseContext

func (*Alter_assembly_client_file_clauseContext) IsAlter_assembly_client_file_clauseContext()

func (*Alter_assembly_client_file_clauseContext) ToStringTree

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

type Alter_assembly_dropContext

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

func NewAlter_assembly_dropContext

func NewAlter_assembly_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_dropContext

func NewEmptyAlter_assembly_dropContext

func NewEmptyAlter_assembly_dropContext() *Alter_assembly_dropContext

func (*Alter_assembly_dropContext) DROP

func (*Alter_assembly_dropContext) EnterRule

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

func (*Alter_assembly_dropContext) ExitRule

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

func (*Alter_assembly_dropContext) GetParser

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

func (*Alter_assembly_dropContext) GetRuleContext

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

func (*Alter_assembly_dropContext) IsAlter_assembly_dropContext

func (*Alter_assembly_dropContext) IsAlter_assembly_dropContext()

func (*Alter_assembly_dropContext) ToStringTree

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

type Alter_assembly_drop_clauseContext

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

func NewAlter_assembly_drop_clauseContext

func NewAlter_assembly_drop_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_drop_clauseContext

func NewEmptyAlter_assembly_drop_clauseContext

func NewEmptyAlter_assembly_drop_clauseContext() *Alter_assembly_drop_clauseContext

func (*Alter_assembly_drop_clauseContext) Alter_assembly_drop

func (*Alter_assembly_drop_clauseContext) Alter_assembly_drop_multiple_files

func (s *Alter_assembly_drop_clauseContext) Alter_assembly_drop_multiple_files() IAlter_assembly_drop_multiple_filesContext

func (*Alter_assembly_drop_clauseContext) EnterRule

func (*Alter_assembly_drop_clauseContext) ExitRule

func (*Alter_assembly_drop_clauseContext) GetParser

func (*Alter_assembly_drop_clauseContext) GetRuleContext

func (*Alter_assembly_drop_clauseContext) IsAlter_assembly_drop_clauseContext

func (*Alter_assembly_drop_clauseContext) IsAlter_assembly_drop_clauseContext()

func (*Alter_assembly_drop_clauseContext) ToStringTree

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

type Alter_assembly_drop_multiple_filesContext

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

func NewAlter_assembly_drop_multiple_filesContext

func NewAlter_assembly_drop_multiple_filesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_drop_multiple_filesContext

func NewEmptyAlter_assembly_drop_multiple_filesContext

func NewEmptyAlter_assembly_drop_multiple_filesContext() *Alter_assembly_drop_multiple_filesContext

func (*Alter_assembly_drop_multiple_filesContext) ALL

func (*Alter_assembly_drop_multiple_filesContext) EnterRule

func (*Alter_assembly_drop_multiple_filesContext) ExitRule

func (*Alter_assembly_drop_multiple_filesContext) GetParser

func (*Alter_assembly_drop_multiple_filesContext) GetRuleContext

func (*Alter_assembly_drop_multiple_filesContext) IsAlter_assembly_drop_multiple_filesContext

func (*Alter_assembly_drop_multiple_filesContext) IsAlter_assembly_drop_multiple_filesContext()

func (*Alter_assembly_drop_multiple_filesContext) Multiple_local_files

func (*Alter_assembly_drop_multiple_filesContext) ToStringTree

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

type Alter_assembly_file_bitsContext

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

func NewAlter_assembly_file_bitsContext

func NewAlter_assembly_file_bitsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_file_bitsContext

func NewEmptyAlter_assembly_file_bitsContext

func NewEmptyAlter_assembly_file_bitsContext() *Alter_assembly_file_bitsContext

func (*Alter_assembly_file_bitsContext) Alter_assembly_as

func (*Alter_assembly_file_bitsContext) EnterRule

func (*Alter_assembly_file_bitsContext) ExitRule

func (*Alter_assembly_file_bitsContext) GetParser

func (*Alter_assembly_file_bitsContext) GetRuleContext

func (*Alter_assembly_file_bitsContext) Id

func (*Alter_assembly_file_bitsContext) IsAlter_assembly_file_bitsContext

func (*Alter_assembly_file_bitsContext) IsAlter_assembly_file_bitsContext()

func (*Alter_assembly_file_bitsContext) ToStringTree

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

type Alter_assembly_file_nameContext

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

func NewAlter_assembly_file_nameContext

func NewAlter_assembly_file_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_file_nameContext

func NewEmptyAlter_assembly_file_nameContext

func NewEmptyAlter_assembly_file_nameContext() *Alter_assembly_file_nameContext

func (*Alter_assembly_file_nameContext) EnterRule

func (*Alter_assembly_file_nameContext) ExitRule

func (*Alter_assembly_file_nameContext) GetParser

func (*Alter_assembly_file_nameContext) GetRuleContext

func (*Alter_assembly_file_nameContext) IsAlter_assembly_file_nameContext

func (*Alter_assembly_file_nameContext) IsAlter_assembly_file_nameContext()

func (*Alter_assembly_file_nameContext) STRING

func (*Alter_assembly_file_nameContext) ToStringTree

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

type Alter_assembly_from_clauseContext

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

func NewAlter_assembly_from_clauseContext

func NewAlter_assembly_from_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_from_clauseContext

func NewEmptyAlter_assembly_from_clauseContext

func NewEmptyAlter_assembly_from_clauseContext() *Alter_assembly_from_clauseContext

func (*Alter_assembly_from_clauseContext) Alter_assembly_file_bits

func (*Alter_assembly_from_clauseContext) Alter_assembly_from_clause_start

func (*Alter_assembly_from_clauseContext) Client_assembly_specifier

func (*Alter_assembly_from_clauseContext) EnterRule

func (*Alter_assembly_from_clauseContext) ExitRule

func (*Alter_assembly_from_clauseContext) GetParser

func (*Alter_assembly_from_clauseContext) GetRuleContext

func (*Alter_assembly_from_clauseContext) IsAlter_assembly_from_clauseContext

func (*Alter_assembly_from_clauseContext) IsAlter_assembly_from_clauseContext()

func (*Alter_assembly_from_clauseContext) ToStringTree

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

type Alter_assembly_from_clause_startContext

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

func NewAlter_assembly_from_clause_startContext

func NewAlter_assembly_from_clause_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_from_clause_startContext

func NewEmptyAlter_assembly_from_clause_startContext

func NewEmptyAlter_assembly_from_clause_startContext() *Alter_assembly_from_clause_startContext

func (*Alter_assembly_from_clause_startContext) EnterRule

func (*Alter_assembly_from_clause_startContext) ExitRule

func (*Alter_assembly_from_clause_startContext) FROM

func (*Alter_assembly_from_clause_startContext) GetParser

func (*Alter_assembly_from_clause_startContext) GetRuleContext

func (*Alter_assembly_from_clause_startContext) IsAlter_assembly_from_clause_startContext

func (*Alter_assembly_from_clause_startContext) IsAlter_assembly_from_clause_startContext()

func (*Alter_assembly_from_clause_startContext) ToStringTree

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

type Alter_assembly_startContext

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

func NewAlter_assembly_startContext

func NewAlter_assembly_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_startContext

func NewEmptyAlter_assembly_startContext

func NewEmptyAlter_assembly_startContext() *Alter_assembly_startContext

func (*Alter_assembly_startContext) ALTER

func (*Alter_assembly_startContext) ASSEMBLY

func (*Alter_assembly_startContext) EnterRule

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

func (*Alter_assembly_startContext) ExitRule

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

func (*Alter_assembly_startContext) GetParser

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

func (*Alter_assembly_startContext) GetRuleContext

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

func (*Alter_assembly_startContext) IsAlter_assembly_startContext

func (*Alter_assembly_startContext) IsAlter_assembly_startContext()

func (*Alter_assembly_startContext) ToStringTree

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

type Alter_assembly_withContext

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

func NewAlter_assembly_withContext

func NewAlter_assembly_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_withContext

func NewEmptyAlter_assembly_withContext

func NewEmptyAlter_assembly_withContext() *Alter_assembly_withContext

func (*Alter_assembly_withContext) EnterRule

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

func (*Alter_assembly_withContext) ExitRule

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

func (*Alter_assembly_withContext) GetParser

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

func (*Alter_assembly_withContext) GetRuleContext

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

func (*Alter_assembly_withContext) IsAlter_assembly_withContext

func (*Alter_assembly_withContext) IsAlter_assembly_withContext()

func (*Alter_assembly_withContext) ToStringTree

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

func (*Alter_assembly_withContext) WITH

type Alter_assembly_with_clauseContext

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

func NewAlter_assembly_with_clauseContext

func NewAlter_assembly_with_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_assembly_with_clauseContext

func NewEmptyAlter_assembly_with_clauseContext

func NewEmptyAlter_assembly_with_clauseContext() *Alter_assembly_with_clauseContext

func (*Alter_assembly_with_clauseContext) Alter_assembly_with

func (*Alter_assembly_with_clauseContext) Assembly_option

func (*Alter_assembly_with_clauseContext) EnterRule

func (*Alter_assembly_with_clauseContext) ExitRule

func (*Alter_assembly_with_clauseContext) GetParser

func (*Alter_assembly_with_clauseContext) GetRuleContext

func (*Alter_assembly_with_clauseContext) IsAlter_assembly_with_clauseContext

func (*Alter_assembly_with_clauseContext) IsAlter_assembly_with_clauseContext()

func (*Alter_assembly_with_clauseContext) ToStringTree

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

type Alter_asssembly_add_clause_startContext

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

func NewAlter_asssembly_add_clause_startContext

func NewAlter_asssembly_add_clause_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_asssembly_add_clause_startContext

func NewEmptyAlter_asssembly_add_clause_startContext

func NewEmptyAlter_asssembly_add_clause_startContext() *Alter_asssembly_add_clause_startContext

func (*Alter_asssembly_add_clause_startContext) ADD

func (*Alter_asssembly_add_clause_startContext) EnterRule

func (*Alter_asssembly_add_clause_startContext) ExitRule

func (*Alter_asssembly_add_clause_startContext) FILE

func (*Alter_asssembly_add_clause_startContext) FROM

func (*Alter_asssembly_add_clause_startContext) GetParser

func (*Alter_asssembly_add_clause_startContext) GetRuleContext

func (*Alter_asssembly_add_clause_startContext) IsAlter_asssembly_add_clause_startContext

func (*Alter_asssembly_add_clause_startContext) IsAlter_asssembly_add_clause_startContext()

func (*Alter_asssembly_add_clause_startContext) ToStringTree

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

type Alter_asymmetric_keyContext

type Alter_asymmetric_keyContext struct {
	*antlr.BaseParserRuleContext

	Asym_Key_Name IIdContext
	// contains filtered or unexported fields
}

func NewAlter_asymmetric_keyContext

func NewAlter_asymmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_asymmetric_keyContext

func NewEmptyAlter_asymmetric_keyContext

func NewEmptyAlter_asymmetric_keyContext() *Alter_asymmetric_keyContext

func (*Alter_asymmetric_keyContext) Alter_asymmetric_key_start

func (s *Alter_asymmetric_keyContext) Alter_asymmetric_key_start() IAlter_asymmetric_key_startContext

func (*Alter_asymmetric_keyContext) Asymmetric_key_option

func (*Alter_asymmetric_keyContext) EnterRule

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

func (*Alter_asymmetric_keyContext) ExitRule

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

func (*Alter_asymmetric_keyContext) GetAsym_Key_Name

func (s *Alter_asymmetric_keyContext) GetAsym_Key_Name() IIdContext

func (*Alter_asymmetric_keyContext) GetParser

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

func (*Alter_asymmetric_keyContext) GetRuleContext

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

func (*Alter_asymmetric_keyContext) Id

func (*Alter_asymmetric_keyContext) IsAlter_asymmetric_keyContext

func (*Alter_asymmetric_keyContext) IsAlter_asymmetric_keyContext()

func (*Alter_asymmetric_keyContext) KEY

func (*Alter_asymmetric_keyContext) PRIVATE

func (*Alter_asymmetric_keyContext) REMOVE

func (*Alter_asymmetric_keyContext) SetAsym_Key_Name

func (s *Alter_asymmetric_keyContext) SetAsym_Key_Name(v IIdContext)

func (*Alter_asymmetric_keyContext) ToStringTree

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

type Alter_asymmetric_key_startContext

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

func NewAlter_asymmetric_key_startContext

func NewAlter_asymmetric_key_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_asymmetric_key_startContext

func NewEmptyAlter_asymmetric_key_startContext

func NewEmptyAlter_asymmetric_key_startContext() *Alter_asymmetric_key_startContext

func (*Alter_asymmetric_key_startContext) ALTER

func (*Alter_asymmetric_key_startContext) ASYMMETRIC

func (*Alter_asymmetric_key_startContext) EnterRule

func (*Alter_asymmetric_key_startContext) ExitRule

func (*Alter_asymmetric_key_startContext) GetParser

func (*Alter_asymmetric_key_startContext) GetRuleContext

func (*Alter_asymmetric_key_startContext) IsAlter_asymmetric_key_startContext

func (*Alter_asymmetric_key_startContext) IsAlter_asymmetric_key_startContext()

func (*Alter_asymmetric_key_startContext) KEY

func (*Alter_asymmetric_key_startContext) ToStringTree

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

type Alter_authorizationContext

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

func NewAlter_authorizationContext

func NewAlter_authorizationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_authorizationContext

func NewEmptyAlter_authorizationContext

func NewEmptyAlter_authorizationContext() *Alter_authorizationContext

func (*Alter_authorizationContext) Alter_authorization_start

func (s *Alter_authorizationContext) Alter_authorization_start() IAlter_authorization_startContext

func (*Alter_authorizationContext) Authorization_grantee

func (s *Alter_authorizationContext) Authorization_grantee() IAuthorization_granteeContext

func (*Alter_authorizationContext) Class_type

func (*Alter_authorizationContext) Colon_colon

func (*Alter_authorizationContext) EnterRule

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

func (*Alter_authorizationContext) Entity_name

func (*Alter_authorizationContext) Entity_to

func (*Alter_authorizationContext) ExitRule

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

func (*Alter_authorizationContext) GetEntity

func (*Alter_authorizationContext) GetParser

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

func (*Alter_authorizationContext) GetRuleContext

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

func (*Alter_authorizationContext) IsAlter_authorizationContext

func (*Alter_authorizationContext) IsAlter_authorizationContext()

func (*Alter_authorizationContext) SetEntity

func (*Alter_authorizationContext) ToStringTree

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

type Alter_authorization_for_azure_dwContext

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

func NewAlter_authorization_for_azure_dwContext

func NewAlter_authorization_for_azure_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_authorization_for_azure_dwContext

func NewEmptyAlter_authorization_for_azure_dwContext

func NewEmptyAlter_authorization_for_azure_dwContext() *Alter_authorization_for_azure_dwContext

func (*Alter_authorization_for_azure_dwContext) Alter_authorization_start

func (*Alter_authorization_for_azure_dwContext) Authorization_grantee

func (*Alter_authorization_for_azure_dwContext) Class_type_for_azure_dw

func (*Alter_authorization_for_azure_dwContext) Colon_colon

func (*Alter_authorization_for_azure_dwContext) EnterRule

func (*Alter_authorization_for_azure_dwContext) Entity_name_for_azure_dw

func (*Alter_authorization_for_azure_dwContext) Entity_to

func (*Alter_authorization_for_azure_dwContext) ExitRule

func (*Alter_authorization_for_azure_dwContext) GetEntity

func (*Alter_authorization_for_azure_dwContext) GetParser

func (*Alter_authorization_for_azure_dwContext) GetRuleContext

func (*Alter_authorization_for_azure_dwContext) IsAlter_authorization_for_azure_dwContext

func (*Alter_authorization_for_azure_dwContext) IsAlter_authorization_for_azure_dwContext()

func (*Alter_authorization_for_azure_dwContext) SetEntity

func (*Alter_authorization_for_azure_dwContext) ToStringTree

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

type Alter_authorization_for_parallel_dwContext

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

func NewAlter_authorization_for_parallel_dwContext

func NewAlter_authorization_for_parallel_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_authorization_for_parallel_dwContext

func NewEmptyAlter_authorization_for_parallel_dwContext

func NewEmptyAlter_authorization_for_parallel_dwContext() *Alter_authorization_for_parallel_dwContext

func (*Alter_authorization_for_parallel_dwContext) Alter_authorization_start

func (*Alter_authorization_for_parallel_dwContext) Authorization_grantee

func (*Alter_authorization_for_parallel_dwContext) Class_type_for_parallel_dw

func (*Alter_authorization_for_parallel_dwContext) Colon_colon

func (*Alter_authorization_for_parallel_dwContext) EnterRule

func (*Alter_authorization_for_parallel_dwContext) Entity_name_for_parallel_dw

func (*Alter_authorization_for_parallel_dwContext) Entity_to

func (*Alter_authorization_for_parallel_dwContext) ExitRule

func (*Alter_authorization_for_parallel_dwContext) GetEntity

func (*Alter_authorization_for_parallel_dwContext) GetParser

func (*Alter_authorization_for_parallel_dwContext) GetRuleContext

func (*Alter_authorization_for_parallel_dwContext) IsAlter_authorization_for_parallel_dwContext

func (*Alter_authorization_for_parallel_dwContext) IsAlter_authorization_for_parallel_dwContext()

func (*Alter_authorization_for_parallel_dwContext) SetEntity

func (*Alter_authorization_for_parallel_dwContext) ToStringTree

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

type Alter_authorization_for_sql_databaseContext

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

func NewAlter_authorization_for_sql_databaseContext

func NewAlter_authorization_for_sql_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_authorization_for_sql_databaseContext

func NewEmptyAlter_authorization_for_sql_databaseContext

func NewEmptyAlter_authorization_for_sql_databaseContext() *Alter_authorization_for_sql_databaseContext

func (*Alter_authorization_for_sql_databaseContext) Alter_authorization_start

func (*Alter_authorization_for_sql_databaseContext) Authorization_grantee

func (*Alter_authorization_for_sql_databaseContext) Class_type_for_sql_database

func (*Alter_authorization_for_sql_databaseContext) Colon_colon

func (*Alter_authorization_for_sql_databaseContext) EnterRule

func (*Alter_authorization_for_sql_databaseContext) Entity_name

func (*Alter_authorization_for_sql_databaseContext) Entity_to

func (*Alter_authorization_for_sql_databaseContext) ExitRule

func (*Alter_authorization_for_sql_databaseContext) GetEntity

func (*Alter_authorization_for_sql_databaseContext) GetParser

func (*Alter_authorization_for_sql_databaseContext) GetRuleContext

func (*Alter_authorization_for_sql_databaseContext) IsAlter_authorization_for_sql_databaseContext

func (*Alter_authorization_for_sql_databaseContext) IsAlter_authorization_for_sql_databaseContext()

func (*Alter_authorization_for_sql_databaseContext) SetEntity

func (*Alter_authorization_for_sql_databaseContext) ToStringTree

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

type Alter_authorization_startContext

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

func NewAlter_authorization_startContext

func NewAlter_authorization_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_authorization_startContext

func NewEmptyAlter_authorization_startContext

func NewEmptyAlter_authorization_startContext() *Alter_authorization_startContext

func (*Alter_authorization_startContext) ALTER

func (*Alter_authorization_startContext) AUTHORIZATION

func (*Alter_authorization_startContext) EnterRule

func (*Alter_authorization_startContext) ExitRule

func (*Alter_authorization_startContext) GetParser

func (*Alter_authorization_startContext) GetRuleContext

func (*Alter_authorization_startContext) IsAlter_authorization_startContext

func (*Alter_authorization_startContext) IsAlter_authorization_startContext()

func (*Alter_authorization_startContext) ON

func (*Alter_authorization_startContext) ToStringTree

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

type Alter_availability_groupContext

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

func NewAlter_availability_groupContext

func NewAlter_availability_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_availability_groupContext

func NewEmptyAlter_availability_groupContext

func NewEmptyAlter_availability_groupContext() *Alter_availability_groupContext

func (*Alter_availability_groupContext) Alter_availability_group_options

func (s *Alter_availability_groupContext) Alter_availability_group_options() IAlter_availability_group_optionsContext

func (*Alter_availability_groupContext) Alter_availability_group_start

func (s *Alter_availability_groupContext) Alter_availability_group_start() IAlter_availability_group_startContext

func (*Alter_availability_groupContext) EnterRule

func (*Alter_availability_groupContext) ExitRule

func (*Alter_availability_groupContext) GetParser

func (*Alter_availability_groupContext) GetRuleContext

func (*Alter_availability_groupContext) IsAlter_availability_groupContext

func (*Alter_availability_groupContext) IsAlter_availability_groupContext()

func (*Alter_availability_groupContext) ToStringTree

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

type Alter_availability_group_optionsContext

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

func NewAlter_availability_group_optionsContext

func NewAlter_availability_group_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_availability_group_optionsContext

func NewEmptyAlter_availability_group_optionsContext

func NewEmptyAlter_availability_group_optionsContext() *Alter_availability_group_optionsContext

func (*Alter_availability_group_optionsContext) ADD

func (*Alter_availability_group_optionsContext) ALL

func (*Alter_availability_group_optionsContext) ALLOW_CONNECTIONS

func (*Alter_availability_group_optionsContext) ANY

func (*Alter_availability_group_optionsContext) ASYNCHRONOUS_COMMIT

func (*Alter_availability_group_optionsContext) AUTOMATED_BACKUP_PREFERENCE

func (s *Alter_availability_group_optionsContext) AUTOMATED_BACKUP_PREFERENCE() antlr.TerminalNode

func (*Alter_availability_group_optionsContext) AUTOMATIC

func (*Alter_availability_group_optionsContext) AVAILABILITY

func (*Alter_availability_group_optionsContext) AVAILABILITY_MODE

func (*Alter_availability_group_optionsContext) AllALLOW_CONNECTIONS

func (s *Alter_availability_group_optionsContext) AllALLOW_CONNECTIONS() []antlr.TerminalNode

func (*Alter_availability_group_optionsContext) AllASYNCHRONOUS_COMMIT

func (s *Alter_availability_group_optionsContext) AllASYNCHRONOUS_COMMIT() []antlr.TerminalNode

func (*Alter_availability_group_optionsContext) AllAUTOMATIC

func (*Alter_availability_group_optionsContext) AllAVAILABILITY_MODE

func (s *Alter_availability_group_optionsContext) AllAVAILABILITY_MODE() []antlr.TerminalNode

func (*Alter_availability_group_optionsContext) AllCOMMA

func (*Alter_availability_group_optionsContext) AllEQUAL

func (*Alter_availability_group_optionsContext) AllFAILOVER_MODE

func (*Alter_availability_group_optionsContext) AllIPV4_ADDR

func (*Alter_availability_group_optionsContext) AllIPV6_ADDR

func (*Alter_availability_group_optionsContext) AllLISTENER_URL

func (*Alter_availability_group_optionsContext) AllLR_BRACKET

func (*Alter_availability_group_optionsContext) AllMANUAL

func (*Alter_availability_group_optionsContext) AllRR_BRACKET

func (*Alter_availability_group_optionsContext) AllSEEDING_MODE

func (*Alter_availability_group_optionsContext) AllSTRING

func (*Alter_availability_group_optionsContext) AllSYNCHRONOUS_COMMIT

func (s *Alter_availability_group_optionsContext) AllSYNCHRONOUS_COMMIT() []antlr.TerminalNode

func (*Alter_availability_group_optionsContext) AllWITH

func (*Alter_availability_group_optionsContext) BACKUP_PRIORITY

func (*Alter_availability_group_optionsContext) COMMA

func (*Alter_availability_group_optionsContext) CREATE

func (*Alter_availability_group_optionsContext) DATABASE

func (*Alter_availability_group_optionsContext) DB_FAILOVER

func (*Alter_availability_group_optionsContext) DECIMAL

func (*Alter_availability_group_optionsContext) DENY

func (*Alter_availability_group_optionsContext) DHCP

func (*Alter_availability_group_optionsContext) DTC_SUPPORT

func (*Alter_availability_group_optionsContext) ENDPOINT_URL

func (*Alter_availability_group_optionsContext) EQUAL

func (*Alter_availability_group_optionsContext) EnterRule

func (*Alter_availability_group_optionsContext) ExitRule

func (*Alter_availability_group_optionsContext) FAILOVER

func (*Alter_availability_group_optionsContext) FAILOVER_MODE

func (*Alter_availability_group_optionsContext) FAILURE_CONDITION_LEVEL

func (s *Alter_availability_group_optionsContext) FAILURE_CONDITION_LEVEL() antlr.TerminalNode

func (*Alter_availability_group_optionsContext) FORCE_FAILOVER_ALLOW_DATA_LOSS

func (s *Alter_availability_group_optionsContext) FORCE_FAILOVER_ALLOW_DATA_LOSS() antlr.TerminalNode

func (*Alter_availability_group_optionsContext) GRANT

func (*Alter_availability_group_optionsContext) GROUP

func (*Alter_availability_group_optionsContext) GetAg_name

func (*Alter_availability_group_optionsContext) GetAg_name_modified

func (s *Alter_availability_group_optionsContext) GetAg_name_modified() antlr.Token

func (*Alter_availability_group_optionsContext) GetDatabase_name

func (*Alter_availability_group_optionsContext) GetListener_name

func (s *Alter_availability_group_optionsContext) GetListener_name() antlr.Token

func (*Alter_availability_group_optionsContext) GetMilliseconds

func (*Alter_availability_group_optionsContext) GetParser

func (*Alter_availability_group_optionsContext) GetRuleContext

func (*Alter_availability_group_optionsContext) GetServer_instance

func (s *Alter_availability_group_optionsContext) GetServer_instance() antlr.Token

func (*Alter_availability_group_optionsContext) GetSession_timeout

func (s *Alter_availability_group_optionsContext) GetSession_timeout() antlr.Token

func (*Alter_availability_group_optionsContext) HEALTH_CHECK_TIMEOUT

func (*Alter_availability_group_optionsContext) IP

func (*Alter_availability_group_optionsContext) IPV4_ADDR

func (*Alter_availability_group_optionsContext) IPV6_ADDR

func (*Alter_availability_group_optionsContext) Id

func (*Alter_availability_group_optionsContext) IsAlter_availability_group_optionsContext

func (*Alter_availability_group_optionsContext) IsAlter_availability_group_optionsContext()

func (*Alter_availability_group_optionsContext) JOIN

func (*Alter_availability_group_optionsContext) LISTENER

func (*Alter_availability_group_optionsContext) LISTENER_URL

func (*Alter_availability_group_optionsContext) LR_BRACKET

func (*Alter_availability_group_optionsContext) MANUAL

func (*Alter_availability_group_optionsContext) MODIFY

func (*Alter_availability_group_optionsContext) NO

func (*Alter_availability_group_optionsContext) NONE

func (*Alter_availability_group_optionsContext) OFF

func (*Alter_availability_group_optionsContext) OFFLINE

func (*Alter_availability_group_optionsContext) ON

func (*Alter_availability_group_optionsContext) PER_DB

func (*Alter_availability_group_optionsContext) PORT

func (*Alter_availability_group_optionsContext) PRIMARY

func (*Alter_availability_group_optionsContext) PRIMARY_ROLE

func (*Alter_availability_group_optionsContext) READ_ONLY

func (*Alter_availability_group_optionsContext) READ_ONLY_ROUTING_LIST

func (s *Alter_availability_group_optionsContext) READ_ONLY_ROUTING_LIST() antlr.TerminalNode

func (*Alter_availability_group_optionsContext) READ_WRITE

func (*Alter_availability_group_optionsContext) REMOVE

func (*Alter_availability_group_optionsContext) REPLICA

func (*Alter_availability_group_optionsContext) REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT

func (s *Alter_availability_group_optionsContext) REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT() antlr.TerminalNode

func (*Alter_availability_group_optionsContext) RESTART

func (*Alter_availability_group_optionsContext) RR_BRACKET

func (*Alter_availability_group_optionsContext) SECONDARY

func (*Alter_availability_group_optionsContext) SECONDARY_ONLY

func (*Alter_availability_group_optionsContext) SECONDARY_ROLE

func (*Alter_availability_group_optionsContext) SEEDING_MODE

func (*Alter_availability_group_optionsContext) SESSION_TIMEOUT

func (*Alter_availability_group_optionsContext) SET

func (*Alter_availability_group_optionsContext) STRING

func (*Alter_availability_group_optionsContext) SYNCHRONOUS_COMMIT

func (*Alter_availability_group_optionsContext) SetAg_name

func (*Alter_availability_group_optionsContext) SetAg_name_modified

func (s *Alter_availability_group_optionsContext) SetAg_name_modified(v antlr.Token)

func (*Alter_availability_group_optionsContext) SetDatabase_name

func (s *Alter_availability_group_optionsContext) SetDatabase_name(v IIdContext)

func (*Alter_availability_group_optionsContext) SetListener_name

func (s *Alter_availability_group_optionsContext) SetListener_name(v antlr.Token)

func (*Alter_availability_group_optionsContext) SetMilliseconds

func (s *Alter_availability_group_optionsContext) SetMilliseconds(v antlr.Token)

func (*Alter_availability_group_optionsContext) SetServer_instance

func (s *Alter_availability_group_optionsContext) SetServer_instance(v antlr.Token)

func (*Alter_availability_group_optionsContext) SetSession_timeout

func (s *Alter_availability_group_optionsContext) SetSession_timeout(v antlr.Token)

func (*Alter_availability_group_optionsContext) ToStringTree

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

func (*Alter_availability_group_optionsContext) WITH

type Alter_availability_group_startContext

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

func NewAlter_availability_group_startContext

func NewAlter_availability_group_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_availability_group_startContext

func NewEmptyAlter_availability_group_startContext

func NewEmptyAlter_availability_group_startContext() *Alter_availability_group_startContext

func (*Alter_availability_group_startContext) ALTER

func (*Alter_availability_group_startContext) AVAILABILITY

func (*Alter_availability_group_startContext) EnterRule

func (*Alter_availability_group_startContext) ExitRule

func (*Alter_availability_group_startContext) GROUP

func (*Alter_availability_group_startContext) GetGroup_name

func (*Alter_availability_group_startContext) GetParser

func (*Alter_availability_group_startContext) GetRuleContext

func (*Alter_availability_group_startContext) Id

func (*Alter_availability_group_startContext) IsAlter_availability_group_startContext

func (*Alter_availability_group_startContext) IsAlter_availability_group_startContext()

func (*Alter_availability_group_startContext) SetGroup_name

func (*Alter_availability_group_startContext) ToStringTree

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

type Alter_certificateContext

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

func NewAlter_certificateContext

func NewAlter_certificateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_certificateContext

func NewEmptyAlter_certificateContext

func NewEmptyAlter_certificateContext() *Alter_certificateContext

func (*Alter_certificateContext) ACTIVE

func (*Alter_certificateContext) ALTER

func (*Alter_certificateContext) AllBY

func (*Alter_certificateContext) AllCOMMA

func (*Alter_certificateContext) AllDECRYPTION

func (s *Alter_certificateContext) AllDECRYPTION() []antlr.TerminalNode

func (*Alter_certificateContext) AllENCRYPTION

func (s *Alter_certificateContext) AllENCRYPTION() []antlr.TerminalNode

func (*Alter_certificateContext) AllEQUAL

func (*Alter_certificateContext) AllFILE

func (*Alter_certificateContext) AllPASSWORD

func (s *Alter_certificateContext) AllPASSWORD() []antlr.TerminalNode

func (*Alter_certificateContext) AllSTRING

func (s *Alter_certificateContext) AllSTRING() []antlr.TerminalNode

func (*Alter_certificateContext) BEGIN_DIALOG

func (s *Alter_certificateContext) BEGIN_DIALOG() antlr.TerminalNode

func (*Alter_certificateContext) BY

func (*Alter_certificateContext) CERTIFICATE

func (s *Alter_certificateContext) CERTIFICATE() antlr.TerminalNode

func (*Alter_certificateContext) COMMA

func (*Alter_certificateContext) DECRYPTION

func (*Alter_certificateContext) ENCRYPTION

func (*Alter_certificateContext) EQUAL

func (*Alter_certificateContext) EnterRule

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

func (*Alter_certificateContext) ExitRule

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

func (*Alter_certificateContext) FILE

func (*Alter_certificateContext) FOR

func (*Alter_certificateContext) GetCertificate_name

func (s *Alter_certificateContext) GetCertificate_name() IIdContext

func (*Alter_certificateContext) GetParser

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

func (*Alter_certificateContext) GetRuleContext

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

func (*Alter_certificateContext) Id

func (*Alter_certificateContext) IsAlter_certificateContext

func (*Alter_certificateContext) IsAlter_certificateContext()

func (*Alter_certificateContext) KEY

func (*Alter_certificateContext) LR_BRACKET

func (*Alter_certificateContext) OFF

func (*Alter_certificateContext) ON

func (*Alter_certificateContext) PASSWORD

func (*Alter_certificateContext) PRIVATE

func (*Alter_certificateContext) PRIVATE_KEY

func (s *Alter_certificateContext) PRIVATE_KEY() antlr.TerminalNode

func (*Alter_certificateContext) REMOVE

func (*Alter_certificateContext) RR_BRACKET

func (*Alter_certificateContext) STRING

func (*Alter_certificateContext) SetCertificate_name

func (s *Alter_certificateContext) SetCertificate_name(v IIdContext)

func (*Alter_certificateContext) ToStringTree

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

func (*Alter_certificateContext) WITH

type Alter_column_encryption_keyContext

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

func NewAlter_column_encryption_keyContext

func NewAlter_column_encryption_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_column_encryption_keyContext

func NewEmptyAlter_column_encryption_keyContext

func NewEmptyAlter_column_encryption_keyContext() *Alter_column_encryption_keyContext

func (*Alter_column_encryption_keyContext) ADD

func (*Alter_column_encryption_keyContext) ALGORITHM

func (*Alter_column_encryption_keyContext) ALTER

func (*Alter_column_encryption_keyContext) AllCOMMA

func (*Alter_column_encryption_keyContext) AllEQUAL

func (*Alter_column_encryption_keyContext) AllId

func (*Alter_column_encryption_keyContext) BINARY

func (*Alter_column_encryption_keyContext) COLUMN

func (*Alter_column_encryption_keyContext) COLUMN_MASTER_KEY

func (s *Alter_column_encryption_keyContext) COLUMN_MASTER_KEY() antlr.TerminalNode

func (*Alter_column_encryption_keyContext) COMMA

func (*Alter_column_encryption_keyContext) DROP

func (*Alter_column_encryption_keyContext) ENCRYPTED_VALUE

func (*Alter_column_encryption_keyContext) ENCRYPTION

func (*Alter_column_encryption_keyContext) EQUAL

func (*Alter_column_encryption_keyContext) EnterRule

func (*Alter_column_encryption_keyContext) ExitRule

func (*Alter_column_encryption_keyContext) GetAlgorithm_name

func (s *Alter_column_encryption_keyContext) GetAlgorithm_name() antlr.Token

func (*Alter_column_encryption_keyContext) GetColumn_encryption_key

func (s *Alter_column_encryption_keyContext) GetColumn_encryption_key() IIdContext

func (*Alter_column_encryption_keyContext) GetColumn_master_key_name

func (s *Alter_column_encryption_keyContext) GetColumn_master_key_name() IIdContext

func (*Alter_column_encryption_keyContext) GetParser

func (*Alter_column_encryption_keyContext) GetRuleContext

func (*Alter_column_encryption_keyContext) Id

func (*Alter_column_encryption_keyContext) IsAlter_column_encryption_keyContext

func (*Alter_column_encryption_keyContext) IsAlter_column_encryption_keyContext()

func (*Alter_column_encryption_keyContext) KEY

func (*Alter_column_encryption_keyContext) LR_BRACKET

func (*Alter_column_encryption_keyContext) RR_BRACKET

func (*Alter_column_encryption_keyContext) STRING

func (*Alter_column_encryption_keyContext) SetAlgorithm_name

func (s *Alter_column_encryption_keyContext) SetAlgorithm_name(v antlr.Token)

func (*Alter_column_encryption_keyContext) SetColumn_encryption_key

func (s *Alter_column_encryption_keyContext) SetColumn_encryption_key(v IIdContext)

func (*Alter_column_encryption_keyContext) SetColumn_master_key_name

func (s *Alter_column_encryption_keyContext) SetColumn_master_key_name(v IIdContext)

func (*Alter_column_encryption_keyContext) ToStringTree

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

func (*Alter_column_encryption_keyContext) VALUE

type Alter_credentialContext

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

func NewAlter_credentialContext

func NewAlter_credentialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_credentialContext

func NewEmptyAlter_credentialContext

func NewEmptyAlter_credentialContext() *Alter_credentialContext

func (*Alter_credentialContext) ALTER

func (*Alter_credentialContext) AllEQUAL

func (s *Alter_credentialContext) AllEQUAL() []antlr.TerminalNode

func (*Alter_credentialContext) AllSTRING

func (s *Alter_credentialContext) AllSTRING() []antlr.TerminalNode

func (*Alter_credentialContext) COMMA

func (*Alter_credentialContext) CREDENTIAL

func (s *Alter_credentialContext) CREDENTIAL() antlr.TerminalNode

func (*Alter_credentialContext) EQUAL

func (*Alter_credentialContext) EnterRule

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

func (*Alter_credentialContext) ExitRule

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

func (*Alter_credentialContext) GetCredential_name

func (s *Alter_credentialContext) GetCredential_name() IIdContext

func (*Alter_credentialContext) GetIdentity_name

func (s *Alter_credentialContext) GetIdentity_name() antlr.Token

func (*Alter_credentialContext) GetParser

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

func (*Alter_credentialContext) GetRuleContext

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

func (*Alter_credentialContext) GetSecret

func (s *Alter_credentialContext) GetSecret() antlr.Token

func (*Alter_credentialContext) IDENTITY

func (*Alter_credentialContext) Id

func (*Alter_credentialContext) IsAlter_credentialContext

func (*Alter_credentialContext) IsAlter_credentialContext()

func (*Alter_credentialContext) SECRET

func (*Alter_credentialContext) STRING

func (*Alter_credentialContext) SetCredential_name

func (s *Alter_credentialContext) SetCredential_name(v IIdContext)

func (*Alter_credentialContext) SetIdentity_name

func (s *Alter_credentialContext) SetIdentity_name(v antlr.Token)

func (*Alter_credentialContext) SetSecret

func (s *Alter_credentialContext) SetSecret(v antlr.Token)

func (*Alter_credentialContext) ToStringTree

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

func (*Alter_credentialContext) WITH

type Alter_cryptographic_providerContext

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

func NewAlter_cryptographic_providerContext

func NewAlter_cryptographic_providerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_cryptographic_providerContext

func NewEmptyAlter_cryptographic_providerContext

func NewEmptyAlter_cryptographic_providerContext() *Alter_cryptographic_providerContext

func (*Alter_cryptographic_providerContext) ALTER

func (*Alter_cryptographic_providerContext) CRYPTOGRAPHIC

func (*Alter_cryptographic_providerContext) DISABLE

func (*Alter_cryptographic_providerContext) ENABLE

func (*Alter_cryptographic_providerContext) EQUAL

func (*Alter_cryptographic_providerContext) EnterRule

func (*Alter_cryptographic_providerContext) ExitRule

func (*Alter_cryptographic_providerContext) FILE

func (*Alter_cryptographic_providerContext) FROM

func (*Alter_cryptographic_providerContext) GetCrypto_provider_ddl_file

func (s *Alter_cryptographic_providerContext) GetCrypto_provider_ddl_file() antlr.Token

func (*Alter_cryptographic_providerContext) GetParser

func (*Alter_cryptographic_providerContext) GetProvider_name

func (s *Alter_cryptographic_providerContext) GetProvider_name() IIdContext

func (*Alter_cryptographic_providerContext) GetRuleContext

func (*Alter_cryptographic_providerContext) Id

func (*Alter_cryptographic_providerContext) IsAlter_cryptographic_providerContext

func (*Alter_cryptographic_providerContext) IsAlter_cryptographic_providerContext()

func (*Alter_cryptographic_providerContext) PROVIDER

func (*Alter_cryptographic_providerContext) STRING

func (*Alter_cryptographic_providerContext) SetCrypto_provider_ddl_file

func (s *Alter_cryptographic_providerContext) SetCrypto_provider_ddl_file(v antlr.Token)

func (*Alter_cryptographic_providerContext) SetProvider_name

func (s *Alter_cryptographic_providerContext) SetProvider_name(v IIdContext)

func (*Alter_cryptographic_providerContext) ToStringTree

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

type Alter_databaseContext

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

func NewAlter_databaseContext

func NewAlter_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_databaseContext

func NewEmptyAlter_databaseContext

func NewEmptyAlter_databaseContext() *Alter_databaseContext

func (*Alter_databaseContext) ALTER

func (*Alter_databaseContext) AllId

func (s *Alter_databaseContext) AllId() []IIdContext

func (*Alter_databaseContext) COLLATE

func (*Alter_databaseContext) CURRENT

func (*Alter_databaseContext) DATABASE

func (*Alter_databaseContext) Database_optionspec

func (s *Alter_databaseContext) Database_optionspec() IDatabase_optionspecContext

func (*Alter_databaseContext) EQUAL

func (*Alter_databaseContext) EnterRule

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

func (*Alter_databaseContext) ExitRule

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

func (*Alter_databaseContext) GetCollation

func (s *Alter_databaseContext) GetCollation() IIdContext

func (*Alter_databaseContext) GetDatabase

func (s *Alter_databaseContext) GetDatabase() IIdContext

func (*Alter_databaseContext) GetNew_name

func (s *Alter_databaseContext) GetNew_name() IIdContext

func (*Alter_databaseContext) GetParser

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

func (*Alter_databaseContext) GetRuleContext

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

func (*Alter_databaseContext) Id

func (*Alter_databaseContext) IsAlter_databaseContext

func (*Alter_databaseContext) IsAlter_databaseContext()

func (*Alter_databaseContext) MODIFY

func (*Alter_databaseContext) NAME

func (*Alter_databaseContext) SEMI

func (*Alter_databaseContext) SET

func (*Alter_databaseContext) SetCollation

func (s *Alter_databaseContext) SetCollation(v IIdContext)

func (*Alter_databaseContext) SetDatabase

func (s *Alter_databaseContext) SetDatabase(v IIdContext)

func (*Alter_databaseContext) SetNew_name

func (s *Alter_databaseContext) SetNew_name(v IIdContext)

func (*Alter_databaseContext) Termination

func (s *Alter_databaseContext) Termination() ITerminationContext

func (*Alter_databaseContext) ToStringTree

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

func (*Alter_databaseContext) WITH

type Alter_db_roleContext

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

func NewAlter_db_roleContext

func NewAlter_db_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_db_roleContext

func NewEmptyAlter_db_roleContext

func NewEmptyAlter_db_roleContext() *Alter_db_roleContext

func (*Alter_db_roleContext) ADD

func (*Alter_db_roleContext) ALTER

func (*Alter_db_roleContext) AllId

func (s *Alter_db_roleContext) AllId() []IIdContext

func (*Alter_db_roleContext) DROP

func (*Alter_db_roleContext) EQUAL

func (*Alter_db_roleContext) EnterRule

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

func (*Alter_db_roleContext) ExitRule

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

func (*Alter_db_roleContext) GetDatabase_principal

func (s *Alter_db_roleContext) GetDatabase_principal() IIdContext

func (*Alter_db_roleContext) GetNew_role_name

func (s *Alter_db_roleContext) GetNew_role_name() IIdContext

func (*Alter_db_roleContext) GetParser

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

func (*Alter_db_roleContext) GetRole_name

func (s *Alter_db_roleContext) GetRole_name() IIdContext

func (*Alter_db_roleContext) GetRuleContext

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

func (*Alter_db_roleContext) Id

func (*Alter_db_roleContext) IsAlter_db_roleContext

func (*Alter_db_roleContext) IsAlter_db_roleContext()

func (*Alter_db_roleContext) MEMBER

func (*Alter_db_roleContext) NAME

func (*Alter_db_roleContext) ROLE

func (*Alter_db_roleContext) SetDatabase_principal

func (s *Alter_db_roleContext) SetDatabase_principal(v IIdContext)

func (*Alter_db_roleContext) SetNew_role_name

func (s *Alter_db_roleContext) SetNew_role_name(v IIdContext)

func (*Alter_db_roleContext) SetRole_name

func (s *Alter_db_roleContext) SetRole_name(v IIdContext)

func (*Alter_db_roleContext) ToStringTree

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

func (*Alter_db_roleContext) WITH

type Alter_endpointContext

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

func NewAlter_endpointContext

func NewAlter_endpointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_endpointContext

func NewEmptyAlter_endpointContext

func NewEmptyAlter_endpointContext() *Alter_endpointContext

func (*Alter_endpointContext) AES

func (*Alter_endpointContext) ALGORITHM

func (s *Alter_endpointContext) ALGORITHM() antlr.TerminalNode

func (*Alter_endpointContext) ALL

func (*Alter_endpointContext) ALTER

func (*Alter_endpointContext) AS

func (*Alter_endpointContext) AUTHENTICATION

func (s *Alter_endpointContext) AUTHENTICATION() antlr.TerminalNode

func (*Alter_endpointContext) AUTHORIZATION

func (s *Alter_endpointContext) AUTHORIZATION() antlr.TerminalNode

func (*Alter_endpointContext) AllALL

func (*Alter_endpointContext) AllCOMMA

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

func (*Alter_endpointContext) AllDECIMAL

func (s *Alter_endpointContext) AllDECIMAL() []antlr.TerminalNode

func (*Alter_endpointContext) AllDISABLED

func (s *Alter_endpointContext) AllDISABLED() []antlr.TerminalNode

func (*Alter_endpointContext) AllEQUAL

func (s *Alter_endpointContext) AllEQUAL() []antlr.TerminalNode

func (*Alter_endpointContext) AllId

func (s *Alter_endpointContext) AllId() []IIdContext

func (*Alter_endpointContext) AllLR_BRACKET

func (s *Alter_endpointContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Alter_endpointContext) AllRR_BRACKET

func (s *Alter_endpointContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Alter_endpointContext) CERTIFICATE

func (s *Alter_endpointContext) CERTIFICATE() antlr.TerminalNode

func (*Alter_endpointContext) COMMA

func (*Alter_endpointContext) DATABASE_MIRRORING

func (s *Alter_endpointContext) DATABASE_MIRRORING() antlr.TerminalNode

func (*Alter_endpointContext) DECIMAL

func (*Alter_endpointContext) DISABLED

func (*Alter_endpointContext) ENABLED

func (*Alter_endpointContext) ENCRYPTION

func (s *Alter_endpointContext) ENCRYPTION() antlr.TerminalNode

func (*Alter_endpointContext) ENDPOINT

func (*Alter_endpointContext) EQUAL

func (*Alter_endpointContext) EnterRule

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

func (*Alter_endpointContext) ExitRule

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

func (*Alter_endpointContext) FOR

func (*Alter_endpointContext) GetCert_name

func (s *Alter_endpointContext) GetCert_name() IIdContext

func (*Alter_endpointContext) GetEndpointname

func (s *Alter_endpointContext) GetEndpointname() IIdContext

func (*Alter_endpointContext) GetLogin

func (s *Alter_endpointContext) GetLogin() IIdContext

func (*Alter_endpointContext) GetParser

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

func (*Alter_endpointContext) GetPort

func (s *Alter_endpointContext) GetPort() antlr.Token

func (*Alter_endpointContext) GetRuleContext

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

func (*Alter_endpointContext) GetState

func (s *Alter_endpointContext) GetState() antlr.Token

func (*Alter_endpointContext) IPV4_ADDR

func (s *Alter_endpointContext) IPV4_ADDR() antlr.TerminalNode

func (*Alter_endpointContext) IPV6_ADDR

func (s *Alter_endpointContext) IPV6_ADDR() antlr.TerminalNode

func (*Alter_endpointContext) Id

func (*Alter_endpointContext) IsAlter_endpointContext

func (*Alter_endpointContext) IsAlter_endpointContext()

func (*Alter_endpointContext) KERBEROS

func (*Alter_endpointContext) LISTENER_IP

func (s *Alter_endpointContext) LISTENER_IP() antlr.TerminalNode

func (*Alter_endpointContext) LISTENER_PORT

func (s *Alter_endpointContext) LISTENER_PORT() antlr.TerminalNode

func (*Alter_endpointContext) LR_BRACKET

func (s *Alter_endpointContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Alter_endpointContext) MESSAGE_FORWARDING

func (s *Alter_endpointContext) MESSAGE_FORWARDING() antlr.TerminalNode

func (*Alter_endpointContext) MESSAGE_FORWARD_SIZE

func (s *Alter_endpointContext) MESSAGE_FORWARD_SIZE() antlr.TerminalNode

func (*Alter_endpointContext) NEGOTIATE

func (s *Alter_endpointContext) NEGOTIATE() antlr.TerminalNode

func (*Alter_endpointContext) NTLM

func (*Alter_endpointContext) PARTNER

func (*Alter_endpointContext) RC4

func (*Alter_endpointContext) REQUIRED

func (*Alter_endpointContext) ROLE

func (*Alter_endpointContext) RR_BRACKET

func (s *Alter_endpointContext) RR_BRACKET(i int) antlr.TerminalNode

func (*Alter_endpointContext) SERVICE_BROKER

func (s *Alter_endpointContext) SERVICE_BROKER() antlr.TerminalNode

func (*Alter_endpointContext) STARTED

func (*Alter_endpointContext) STATE

func (*Alter_endpointContext) STOPPED

func (*Alter_endpointContext) SUPPORTED

func (s *Alter_endpointContext) SUPPORTED() antlr.TerminalNode

func (*Alter_endpointContext) SetCert_name

func (s *Alter_endpointContext) SetCert_name(v IIdContext)

func (*Alter_endpointContext) SetEndpointname

func (s *Alter_endpointContext) SetEndpointname(v IIdContext)

func (*Alter_endpointContext) SetLogin

func (s *Alter_endpointContext) SetLogin(v IIdContext)

func (*Alter_endpointContext) SetPort

func (s *Alter_endpointContext) SetPort(v antlr.Token)

func (*Alter_endpointContext) SetState

func (s *Alter_endpointContext) SetState(v antlr.Token)

func (*Alter_endpointContext) TCP

func (*Alter_endpointContext) TSQL

func (*Alter_endpointContext) ToStringTree

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

func (*Alter_endpointContext) WINDOWS

func (*Alter_endpointContext) WITNESS

type Alter_external_data_sourceContext

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

func NewAlter_external_data_sourceContext

func NewAlter_external_data_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_external_data_sourceContext

func NewEmptyAlter_external_data_sourceContext

func NewEmptyAlter_external_data_sourceContext() *Alter_external_data_sourceContext

func (*Alter_external_data_sourceContext) ALTER

func (*Alter_external_data_sourceContext) AllCOMMA

func (*Alter_external_data_sourceContext) AllCREDENTIAL

func (*Alter_external_data_sourceContext) AllEQUAL

func (*Alter_external_data_sourceContext) AllId

func (*Alter_external_data_sourceContext) AllLOCATION

func (*Alter_external_data_sourceContext) AllQUOTED_HOST_AND_PORT

func (s *Alter_external_data_sourceContext) AllQUOTED_HOST_AND_PORT() []antlr.TerminalNode

func (*Alter_external_data_sourceContext) AllQUOTED_URL

func (*Alter_external_data_sourceContext) AllRESOURCE_MANAGER_LOCATION

func (s *Alter_external_data_sourceContext) AllRESOURCE_MANAGER_LOCATION() []antlr.TerminalNode

func (*Alter_external_data_sourceContext) BLOB_STORAGE

func (*Alter_external_data_sourceContext) COMMA

func (*Alter_external_data_sourceContext) CREDENTIAL

func (*Alter_external_data_sourceContext) DATA

func (*Alter_external_data_sourceContext) EQUAL

func (*Alter_external_data_sourceContext) EXTERNAL

func (*Alter_external_data_sourceContext) EnterRule

func (*Alter_external_data_sourceContext) ExitRule

func (*Alter_external_data_sourceContext) GetCredential_name

func (s *Alter_external_data_sourceContext) GetCredential_name() IIdContext

func (*Alter_external_data_sourceContext) GetData_source_name

func (s *Alter_external_data_sourceContext) GetData_source_name() IIdContext

func (*Alter_external_data_sourceContext) GetLocation

func (*Alter_external_data_sourceContext) GetParser

func (*Alter_external_data_sourceContext) GetResource_manager_location

func (s *Alter_external_data_sourceContext) GetResource_manager_location() antlr.Token

func (*Alter_external_data_sourceContext) GetRuleContext

func (*Alter_external_data_sourceContext) Id

func (*Alter_external_data_sourceContext) IsAlter_external_data_sourceContext

func (*Alter_external_data_sourceContext) IsAlter_external_data_sourceContext()

func (*Alter_external_data_sourceContext) LOCATION

func (*Alter_external_data_sourceContext) LR_BRACKET

func (*Alter_external_data_sourceContext) QUOTED_HOST_AND_PORT

func (s *Alter_external_data_sourceContext) QUOTED_HOST_AND_PORT(i int) antlr.TerminalNode

func (*Alter_external_data_sourceContext) QUOTED_URL

func (*Alter_external_data_sourceContext) RESOURCE_MANAGER_LOCATION

func (s *Alter_external_data_sourceContext) RESOURCE_MANAGER_LOCATION(i int) antlr.TerminalNode

func (*Alter_external_data_sourceContext) RR_BRACKET

func (*Alter_external_data_sourceContext) SET

func (*Alter_external_data_sourceContext) SOURCE

func (*Alter_external_data_sourceContext) STRING

func (*Alter_external_data_sourceContext) SetCredential_name

func (s *Alter_external_data_sourceContext) SetCredential_name(v IIdContext)

func (*Alter_external_data_sourceContext) SetData_source_name

func (s *Alter_external_data_sourceContext) SetData_source_name(v IIdContext)

func (*Alter_external_data_sourceContext) SetLocation

func (s *Alter_external_data_sourceContext) SetLocation(v antlr.Token)

func (*Alter_external_data_sourceContext) SetResource_manager_location

func (s *Alter_external_data_sourceContext) SetResource_manager_location(v antlr.Token)

func (*Alter_external_data_sourceContext) TYPE

func (*Alter_external_data_sourceContext) ToStringTree

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

func (*Alter_external_data_sourceContext) WITH

type Alter_external_libraryContext

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

func NewAlter_external_libraryContext

func NewAlter_external_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_external_libraryContext

func NewEmptyAlter_external_libraryContext

func NewEmptyAlter_external_libraryContext() *Alter_external_libraryContext

func (*Alter_external_libraryContext) ADD

func (*Alter_external_libraryContext) ALTER

func (*Alter_external_libraryContext) AUTHORIZATION

func (*Alter_external_libraryContext) AllCOMMA

func (*Alter_external_libraryContext) AllDATA_SOURCE

func (s *Alter_external_libraryContext) AllDATA_SOURCE() []antlr.TerminalNode

func (*Alter_external_libraryContext) AllEQUAL

func (*Alter_external_libraryContext) AllId

func (*Alter_external_libraryContext) AllLANGUAGE

func (*Alter_external_libraryContext) AllPYTHON

func (*Alter_external_libraryContext) AllR

func (*Alter_external_libraryContext) AllRR_BRACKET

func (s *Alter_external_libraryContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Alter_external_libraryContext) BINARY

func (*Alter_external_libraryContext) COMMA

func (*Alter_external_libraryContext) CONTENT

func (*Alter_external_libraryContext) DATA_SOURCE

func (*Alter_external_libraryContext) EQUAL

func (*Alter_external_libraryContext) EXTERNAL

func (*Alter_external_libraryContext) EnterRule

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

func (*Alter_external_libraryContext) ExitRule

func (*Alter_external_libraryContext) GetClient_library

func (s *Alter_external_libraryContext) GetClient_library() antlr.Token

func (*Alter_external_libraryContext) GetExternal_data_source_name

func (s *Alter_external_libraryContext) GetExternal_data_source_name() IIdContext

func (*Alter_external_libraryContext) GetLibrary_name

func (s *Alter_external_libraryContext) GetLibrary_name() IIdContext

func (*Alter_external_libraryContext) GetOwner_name

func (s *Alter_external_libraryContext) GetOwner_name() IIdContext

func (*Alter_external_libraryContext) GetParser

func (*Alter_external_libraryContext) GetRuleContext

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

func (*Alter_external_libraryContext) Id

func (*Alter_external_libraryContext) IsAlter_external_libraryContext

func (*Alter_external_libraryContext) IsAlter_external_libraryContext()

func (*Alter_external_libraryContext) LANGUAGE

func (*Alter_external_libraryContext) LIBRARY

func (*Alter_external_libraryContext) LINUX

func (*Alter_external_libraryContext) LR_BRACKET

func (*Alter_external_libraryContext) NONE

func (*Alter_external_libraryContext) PLATFORM

func (*Alter_external_libraryContext) PYTHON

func (*Alter_external_libraryContext) R

func (*Alter_external_libraryContext) RR_BRACKET

func (*Alter_external_libraryContext) SET

func (*Alter_external_libraryContext) STRING

func (*Alter_external_libraryContext) SetClient_library

func (s *Alter_external_libraryContext) SetClient_library(v antlr.Token)

func (*Alter_external_libraryContext) SetExternal_data_source_name

func (s *Alter_external_libraryContext) SetExternal_data_source_name(v IIdContext)

func (*Alter_external_libraryContext) SetLibrary_name

func (s *Alter_external_libraryContext) SetLibrary_name(v IIdContext)

func (*Alter_external_libraryContext) SetOwner_name

func (s *Alter_external_libraryContext) SetOwner_name(v IIdContext)

func (*Alter_external_libraryContext) ToStringTree

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

func (*Alter_external_libraryContext) WINDOWS

func (*Alter_external_libraryContext) WITH

type Alter_external_resource_poolContext

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

func NewAlter_external_resource_poolContext

func NewAlter_external_resource_poolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_external_resource_poolContext

func NewEmptyAlter_external_resource_poolContext

func NewEmptyAlter_external_resource_poolContext() *Alter_external_resource_poolContext

func (*Alter_external_resource_poolContext) AFFINITY

func (*Alter_external_resource_poolContext) ALTER

func (*Alter_external_resource_poolContext) AUTO

func (*Alter_external_resource_poolContext) AllCOMMA

func (*Alter_external_resource_poolContext) AllDECIMAL

func (*Alter_external_resource_poolContext) AllEQUAL

func (*Alter_external_resource_poolContext) AllTO

func (*Alter_external_resource_poolContext) COMMA

func (*Alter_external_resource_poolContext) CPU

func (*Alter_external_resource_poolContext) DECIMAL

func (*Alter_external_resource_poolContext) DEFAULT_DOUBLE_QUOTE

func (s *Alter_external_resource_poolContext) DEFAULT_DOUBLE_QUOTE() antlr.TerminalNode

func (*Alter_external_resource_poolContext) EQUAL

func (*Alter_external_resource_poolContext) EXTERNAL

func (*Alter_external_resource_poolContext) EnterRule

func (*Alter_external_resource_poolContext) ExitRule

func (*Alter_external_resource_poolContext) GetMax_cpu_percent

func (s *Alter_external_resource_poolContext) GetMax_cpu_percent() antlr.Token

func (*Alter_external_resource_poolContext) GetMax_memory_percent

func (s *Alter_external_resource_poolContext) GetMax_memory_percent() antlr.Token

func (*Alter_external_resource_poolContext) GetMax_processes

func (s *Alter_external_resource_poolContext) GetMax_processes() antlr.Token

func (*Alter_external_resource_poolContext) GetParser

func (*Alter_external_resource_poolContext) GetPool_name

func (*Alter_external_resource_poolContext) GetRuleContext

func (*Alter_external_resource_poolContext) Id

func (*Alter_external_resource_poolContext) IsAlter_external_resource_poolContext

func (*Alter_external_resource_poolContext) IsAlter_external_resource_poolContext()

func (*Alter_external_resource_poolContext) LR_BRACKET

func (*Alter_external_resource_poolContext) MAX_CPU_PERCENT

func (*Alter_external_resource_poolContext) MAX_MEMORY_PERCENT

func (s *Alter_external_resource_poolContext) MAX_MEMORY_PERCENT() antlr.TerminalNode

func (*Alter_external_resource_poolContext) MAX_PROCESSES

func (*Alter_external_resource_poolContext) NUMANODE

func (*Alter_external_resource_poolContext) POOL

func (*Alter_external_resource_poolContext) RESOURCE

func (*Alter_external_resource_poolContext) RR_BRACKET

func (*Alter_external_resource_poolContext) SetMax_cpu_percent

func (s *Alter_external_resource_poolContext) SetMax_cpu_percent(v antlr.Token)

func (*Alter_external_resource_poolContext) SetMax_memory_percent

func (s *Alter_external_resource_poolContext) SetMax_memory_percent(v antlr.Token)

func (*Alter_external_resource_poolContext) SetMax_processes

func (s *Alter_external_resource_poolContext) SetMax_processes(v antlr.Token)

func (*Alter_external_resource_poolContext) SetPool_name

func (*Alter_external_resource_poolContext) TO

func (*Alter_external_resource_poolContext) ToStringTree

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

func (*Alter_external_resource_poolContext) WITH

type Alter_fulltext_catalogContext

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

func NewAlter_fulltext_catalogContext

func NewAlter_fulltext_catalogContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_fulltext_catalogContext

func NewEmptyAlter_fulltext_catalogContext

func NewEmptyAlter_fulltext_catalogContext() *Alter_fulltext_catalogContext

func (*Alter_fulltext_catalogContext) ACCENT_SENSITIVITY

func (s *Alter_fulltext_catalogContext) ACCENT_SENSITIVITY() antlr.TerminalNode

func (*Alter_fulltext_catalogContext) ALTER

func (*Alter_fulltext_catalogContext) AS

func (*Alter_fulltext_catalogContext) CATALOG

func (*Alter_fulltext_catalogContext) DEFAULT

func (*Alter_fulltext_catalogContext) EQUAL

func (*Alter_fulltext_catalogContext) EnterRule

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

func (*Alter_fulltext_catalogContext) ExitRule

func (*Alter_fulltext_catalogContext) FULLTEXT

func (*Alter_fulltext_catalogContext) GetCatalog_name

func (s *Alter_fulltext_catalogContext) GetCatalog_name() IIdContext

func (*Alter_fulltext_catalogContext) GetParser

func (*Alter_fulltext_catalogContext) GetRuleContext

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

func (*Alter_fulltext_catalogContext) Id

func (*Alter_fulltext_catalogContext) IsAlter_fulltext_catalogContext

func (*Alter_fulltext_catalogContext) IsAlter_fulltext_catalogContext()

func (*Alter_fulltext_catalogContext) OFF

func (*Alter_fulltext_catalogContext) ON

func (*Alter_fulltext_catalogContext) REBUILD

func (*Alter_fulltext_catalogContext) REORGANIZE

func (*Alter_fulltext_catalogContext) SetCatalog_name

func (s *Alter_fulltext_catalogContext) SetCatalog_name(v IIdContext)

func (*Alter_fulltext_catalogContext) ToStringTree

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

func (*Alter_fulltext_catalogContext) WITH

type Alter_fulltext_stoplistContext

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

func NewAlter_fulltext_stoplistContext

func NewAlter_fulltext_stoplistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_fulltext_stoplistContext

func NewEmptyAlter_fulltext_stoplistContext

func NewEmptyAlter_fulltext_stoplistContext() *Alter_fulltext_stoplistContext

func (*Alter_fulltext_stoplistContext) ADD

func (*Alter_fulltext_stoplistContext) ALL

func (*Alter_fulltext_stoplistContext) ALTER

func (*Alter_fulltext_stoplistContext) AllSTRING

func (*Alter_fulltext_stoplistContext) BINARY

func (*Alter_fulltext_stoplistContext) DECIMAL

func (*Alter_fulltext_stoplistContext) DROP

func (*Alter_fulltext_stoplistContext) EnterRule

func (*Alter_fulltext_stoplistContext) ExitRule

func (*Alter_fulltext_stoplistContext) FULLTEXT

func (*Alter_fulltext_stoplistContext) GetParser

func (*Alter_fulltext_stoplistContext) GetRuleContext

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

func (*Alter_fulltext_stoplistContext) GetStoplist_name

func (s *Alter_fulltext_stoplistContext) GetStoplist_name() IIdContext

func (*Alter_fulltext_stoplistContext) GetStopword

func (s *Alter_fulltext_stoplistContext) GetStopword() antlr.Token

func (*Alter_fulltext_stoplistContext) Id

func (*Alter_fulltext_stoplistContext) IsAlter_fulltext_stoplistContext

func (*Alter_fulltext_stoplistContext) IsAlter_fulltext_stoplistContext()

func (*Alter_fulltext_stoplistContext) LANGUAGE

func (*Alter_fulltext_stoplistContext) STOPLIST

func (*Alter_fulltext_stoplistContext) STRING

func (*Alter_fulltext_stoplistContext) SetStoplist_name

func (s *Alter_fulltext_stoplistContext) SetStoplist_name(v IIdContext)

func (*Alter_fulltext_stoplistContext) SetStopword

func (s *Alter_fulltext_stoplistContext) SetStopword(v antlr.Token)

func (*Alter_fulltext_stoplistContext) ToStringTree

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

type Alter_login_azure_sqlContext

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

func NewAlter_login_azure_sqlContext

func NewAlter_login_azure_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_login_azure_sqlContext

func NewEmptyAlter_login_azure_sqlContext

func NewEmptyAlter_login_azure_sqlContext() *Alter_login_azure_sqlContext

func (*Alter_login_azure_sqlContext) ALTER

func (*Alter_login_azure_sqlContext) AllEQUAL

func (*Alter_login_azure_sqlContext) AllId

func (*Alter_login_azure_sqlContext) AllSTRING

func (*Alter_login_azure_sqlContext) DISABLE

func (*Alter_login_azure_sqlContext) ENABLE

func (*Alter_login_azure_sqlContext) EQUAL

func (*Alter_login_azure_sqlContext) EnterRule

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

func (*Alter_login_azure_sqlContext) ExitRule

func (*Alter_login_azure_sqlContext) GetLogin_name

func (s *Alter_login_azure_sqlContext) GetLogin_name() IIdContext

func (*Alter_login_azure_sqlContext) GetOld_password

func (s *Alter_login_azure_sqlContext) GetOld_password() antlr.Token

func (*Alter_login_azure_sqlContext) GetParser

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

func (*Alter_login_azure_sqlContext) GetPassword

func (s *Alter_login_azure_sqlContext) GetPassword() antlr.Token

func (*Alter_login_azure_sqlContext) GetRuleContext

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

func (*Alter_login_azure_sqlContext) Id

func (*Alter_login_azure_sqlContext) IsAlter_login_azure_sqlContext

func (*Alter_login_azure_sqlContext) IsAlter_login_azure_sqlContext()

func (*Alter_login_azure_sqlContext) LOGIN

func (*Alter_login_azure_sqlContext) NAME

func (*Alter_login_azure_sqlContext) OLD_PASSWORD

func (*Alter_login_azure_sqlContext) PASSWORD

func (*Alter_login_azure_sqlContext) STRING

func (*Alter_login_azure_sqlContext) SetLogin_name

func (s *Alter_login_azure_sqlContext) SetLogin_name(v IIdContext)

func (*Alter_login_azure_sqlContext) SetOld_password

func (s *Alter_login_azure_sqlContext) SetOld_password(v antlr.Token)

func (*Alter_login_azure_sqlContext) SetPassword

func (s *Alter_login_azure_sqlContext) SetPassword(v antlr.Token)

func (*Alter_login_azure_sqlContext) ToStringTree

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

func (*Alter_login_azure_sqlContext) WITH

type Alter_login_azure_sql_dw_and_pdwContext

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

func NewAlter_login_azure_sql_dw_and_pdwContext

func NewAlter_login_azure_sql_dw_and_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_login_azure_sql_dw_and_pdwContext

func NewEmptyAlter_login_azure_sql_dw_and_pdwContext

func NewEmptyAlter_login_azure_sql_dw_and_pdwContext() *Alter_login_azure_sql_dw_and_pdwContext

func (*Alter_login_azure_sql_dw_and_pdwContext) ALTER

func (*Alter_login_azure_sql_dw_and_pdwContext) AllEQUAL

func (*Alter_login_azure_sql_dw_and_pdwContext) AllId

func (*Alter_login_azure_sql_dw_and_pdwContext) AllMUST_CHANGE

func (*Alter_login_azure_sql_dw_and_pdwContext) AllSTRING

func (*Alter_login_azure_sql_dw_and_pdwContext) AllUNLOCK

func (*Alter_login_azure_sql_dw_and_pdwContext) DISABLE

func (*Alter_login_azure_sql_dw_and_pdwContext) ENABLE

func (*Alter_login_azure_sql_dw_and_pdwContext) EQUAL

func (*Alter_login_azure_sql_dw_and_pdwContext) EnterRule

func (*Alter_login_azure_sql_dw_and_pdwContext) ExitRule

func (*Alter_login_azure_sql_dw_and_pdwContext) GetLogin_name

func (*Alter_login_azure_sql_dw_and_pdwContext) GetOld_password

func (*Alter_login_azure_sql_dw_and_pdwContext) GetParser

func (*Alter_login_azure_sql_dw_and_pdwContext) GetPassword

func (*Alter_login_azure_sql_dw_and_pdwContext) GetRuleContext

func (*Alter_login_azure_sql_dw_and_pdwContext) Id

func (*Alter_login_azure_sql_dw_and_pdwContext) IsAlter_login_azure_sql_dw_and_pdwContext

func (*Alter_login_azure_sql_dw_and_pdwContext) IsAlter_login_azure_sql_dw_and_pdwContext()

func (*Alter_login_azure_sql_dw_and_pdwContext) LOGIN

func (*Alter_login_azure_sql_dw_and_pdwContext) MUST_CHANGE

func (*Alter_login_azure_sql_dw_and_pdwContext) NAME

func (*Alter_login_azure_sql_dw_and_pdwContext) OLD_PASSWORD

func (*Alter_login_azure_sql_dw_and_pdwContext) PASSWORD

func (*Alter_login_azure_sql_dw_and_pdwContext) STRING

func (*Alter_login_azure_sql_dw_and_pdwContext) SetLogin_name

func (*Alter_login_azure_sql_dw_and_pdwContext) SetOld_password

func (s *Alter_login_azure_sql_dw_and_pdwContext) SetOld_password(v antlr.Token)

func (*Alter_login_azure_sql_dw_and_pdwContext) SetPassword

func (*Alter_login_azure_sql_dw_and_pdwContext) ToStringTree

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

func (*Alter_login_azure_sql_dw_and_pdwContext) UNLOCK

func (*Alter_login_azure_sql_dw_and_pdwContext) WITH

type Alter_login_sql_serverContext

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

func NewAlter_login_sql_serverContext

func NewAlter_login_sql_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_login_sql_serverContext

func NewEmptyAlter_login_sql_serverContext

func NewEmptyAlter_login_sql_serverContext() *Alter_login_sql_serverContext

func (*Alter_login_sql_serverContext) ADD

func (*Alter_login_sql_serverContext) ALTER

func (*Alter_login_sql_serverContext) AllCREDENTIAL

func (s *Alter_login_sql_serverContext) AllCREDENTIAL() []antlr.TerminalNode

func (*Alter_login_sql_serverContext) AllEQUAL

func (*Alter_login_sql_serverContext) AllId

func (*Alter_login_sql_serverContext) AllMUST_CHANGE

func (s *Alter_login_sql_serverContext) AllMUST_CHANGE() []antlr.TerminalNode

func (*Alter_login_sql_serverContext) AllOFF

func (*Alter_login_sql_serverContext) AllON

func (*Alter_login_sql_serverContext) AllSTRING

func (*Alter_login_sql_serverContext) AllUNLOCK

func (*Alter_login_sql_serverContext) BINARY

func (*Alter_login_sql_serverContext) CHECK_EXPIRATION

func (s *Alter_login_sql_serverContext) CHECK_EXPIRATION() antlr.TerminalNode

func (*Alter_login_sql_serverContext) CHECK_POLICY

func (*Alter_login_sql_serverContext) CREDENTIAL

func (*Alter_login_sql_serverContext) DEFAULT_DATABASE

func (s *Alter_login_sql_serverContext) DEFAULT_DATABASE() antlr.TerminalNode

func (*Alter_login_sql_serverContext) DEFAULT_LANGUAGE

func (s *Alter_login_sql_serverContext) DEFAULT_LANGUAGE() antlr.TerminalNode

func (*Alter_login_sql_serverContext) DISABLE

func (*Alter_login_sql_serverContext) DROP

func (*Alter_login_sql_serverContext) ENABLE

func (*Alter_login_sql_serverContext) EQUAL

func (*Alter_login_sql_serverContext) EnterRule

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

func (*Alter_login_sql_serverContext) ExitRule

func (*Alter_login_sql_serverContext) GetCredential_name

func (s *Alter_login_sql_serverContext) GetCredential_name() IIdContext

func (*Alter_login_sql_serverContext) GetDefault_database

func (s *Alter_login_sql_serverContext) GetDefault_database() IIdContext

func (*Alter_login_sql_serverContext) GetDefault_laguage

func (s *Alter_login_sql_serverContext) GetDefault_laguage() IIdContext

func (*Alter_login_sql_serverContext) GetLogin_name

func (s *Alter_login_sql_serverContext) GetLogin_name() IIdContext

func (*Alter_login_sql_serverContext) GetOld_password

func (s *Alter_login_sql_serverContext) GetOld_password() antlr.Token

func (*Alter_login_sql_serverContext) GetParser

func (*Alter_login_sql_serverContext) GetPassword

func (s *Alter_login_sql_serverContext) GetPassword() antlr.Token

func (*Alter_login_sql_serverContext) GetPassword_hash

func (s *Alter_login_sql_serverContext) GetPassword_hash() antlr.Token

func (*Alter_login_sql_serverContext) GetRuleContext

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

func (*Alter_login_sql_serverContext) HASHED

func (*Alter_login_sql_serverContext) Id

func (*Alter_login_sql_serverContext) IsAlter_login_sql_serverContext

func (*Alter_login_sql_serverContext) IsAlter_login_sql_serverContext()

func (*Alter_login_sql_serverContext) LOGIN

func (*Alter_login_sql_serverContext) MUST_CHANGE

func (*Alter_login_sql_serverContext) NAME

func (*Alter_login_sql_serverContext) NO

func (*Alter_login_sql_serverContext) OFF

func (*Alter_login_sql_serverContext) OLD_PASSWORD

func (*Alter_login_sql_serverContext) ON

func (*Alter_login_sql_serverContext) PASSWORD

func (*Alter_login_sql_serverContext) STRING

func (*Alter_login_sql_serverContext) SetCredential_name

func (s *Alter_login_sql_serverContext) SetCredential_name(v IIdContext)

func (*Alter_login_sql_serverContext) SetDefault_database

func (s *Alter_login_sql_serverContext) SetDefault_database(v IIdContext)

func (*Alter_login_sql_serverContext) SetDefault_laguage

func (s *Alter_login_sql_serverContext) SetDefault_laguage(v IIdContext)

func (*Alter_login_sql_serverContext) SetLogin_name

func (s *Alter_login_sql_serverContext) SetLogin_name(v IIdContext)

func (*Alter_login_sql_serverContext) SetOld_password

func (s *Alter_login_sql_serverContext) SetOld_password(v antlr.Token)

func (*Alter_login_sql_serverContext) SetPassword

func (s *Alter_login_sql_serverContext) SetPassword(v antlr.Token)

func (*Alter_login_sql_serverContext) SetPassword_hash

func (s *Alter_login_sql_serverContext) SetPassword_hash(v antlr.Token)

func (*Alter_login_sql_serverContext) ToStringTree

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

func (*Alter_login_sql_serverContext) UNLOCK

func (*Alter_login_sql_serverContext) WITH

type Alter_master_key_azure_sqlContext

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

func NewAlter_master_key_azure_sqlContext

func NewAlter_master_key_azure_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_master_key_azure_sqlContext

func NewEmptyAlter_master_key_azure_sqlContext

func NewEmptyAlter_master_key_azure_sqlContext() *Alter_master_key_azure_sqlContext

func (*Alter_master_key_azure_sqlContext) ADD

func (*Alter_master_key_azure_sqlContext) ALTER

func (*Alter_master_key_azure_sqlContext) AllKEY

func (*Alter_master_key_azure_sqlContext) AllMASTER

func (*Alter_master_key_azure_sqlContext) BY

func (*Alter_master_key_azure_sqlContext) DROP

func (*Alter_master_key_azure_sqlContext) ENCRYPTION

func (*Alter_master_key_azure_sqlContext) EQUAL

func (*Alter_master_key_azure_sqlContext) EnterRule

func (*Alter_master_key_azure_sqlContext) ExitRule

func (*Alter_master_key_azure_sqlContext) FORCE

func (*Alter_master_key_azure_sqlContext) GetEncryption_password

func (s *Alter_master_key_azure_sqlContext) GetEncryption_password() antlr.Token

func (*Alter_master_key_azure_sqlContext) GetParser

func (*Alter_master_key_azure_sqlContext) GetPassword

func (*Alter_master_key_azure_sqlContext) GetRuleContext

func (*Alter_master_key_azure_sqlContext) IsAlter_master_key_azure_sqlContext

func (*Alter_master_key_azure_sqlContext) IsAlter_master_key_azure_sqlContext()

func (*Alter_master_key_azure_sqlContext) KEY

func (*Alter_master_key_azure_sqlContext) MASTER

func (*Alter_master_key_azure_sqlContext) PASSWORD

func (*Alter_master_key_azure_sqlContext) REGENERATE

func (*Alter_master_key_azure_sqlContext) SERVICE

func (*Alter_master_key_azure_sqlContext) STRING

func (*Alter_master_key_azure_sqlContext) SetEncryption_password

func (s *Alter_master_key_azure_sqlContext) SetEncryption_password(v antlr.Token)

func (*Alter_master_key_azure_sqlContext) SetPassword

func (s *Alter_master_key_azure_sqlContext) SetPassword(v antlr.Token)

func (*Alter_master_key_azure_sqlContext) ToStringTree

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

func (*Alter_master_key_azure_sqlContext) WITH

type Alter_master_key_sql_serverContext

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

func NewAlter_master_key_sql_serverContext

func NewAlter_master_key_sql_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_master_key_sql_serverContext

func NewEmptyAlter_master_key_sql_serverContext

func NewEmptyAlter_master_key_sql_serverContext() *Alter_master_key_sql_serverContext

func (*Alter_master_key_sql_serverContext) ADD

func (*Alter_master_key_sql_serverContext) ALTER

func (*Alter_master_key_sql_serverContext) AllKEY

func (*Alter_master_key_sql_serverContext) AllMASTER

func (*Alter_master_key_sql_serverContext) BY

func (*Alter_master_key_sql_serverContext) DROP

func (*Alter_master_key_sql_serverContext) ENCRYPTION

func (*Alter_master_key_sql_serverContext) EQUAL

func (*Alter_master_key_sql_serverContext) EnterRule

func (*Alter_master_key_sql_serverContext) ExitRule

func (*Alter_master_key_sql_serverContext) FORCE

func (*Alter_master_key_sql_serverContext) GetEncryption_password

func (s *Alter_master_key_sql_serverContext) GetEncryption_password() antlr.Token

func (*Alter_master_key_sql_serverContext) GetParser

func (*Alter_master_key_sql_serverContext) GetPassword

func (*Alter_master_key_sql_serverContext) GetRuleContext

func (*Alter_master_key_sql_serverContext) IsAlter_master_key_sql_serverContext

func (*Alter_master_key_sql_serverContext) IsAlter_master_key_sql_serverContext()

func (*Alter_master_key_sql_serverContext) KEY

func (*Alter_master_key_sql_serverContext) MASTER

func (*Alter_master_key_sql_serverContext) PASSWORD

func (*Alter_master_key_sql_serverContext) REGENERATE

func (*Alter_master_key_sql_serverContext) SERVICE

func (*Alter_master_key_sql_serverContext) STRING

func (*Alter_master_key_sql_serverContext) SetEncryption_password

func (s *Alter_master_key_sql_serverContext) SetEncryption_password(v antlr.Token)

func (*Alter_master_key_sql_serverContext) SetPassword

func (*Alter_master_key_sql_serverContext) ToStringTree

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

func (*Alter_master_key_sql_serverContext) WITH

type Alter_message_typeContext

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

func NewAlter_message_typeContext

func NewAlter_message_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_message_typeContext

func NewEmptyAlter_message_typeContext

func NewEmptyAlter_message_typeContext() *Alter_message_typeContext

func (*Alter_message_typeContext) ALTER

func (*Alter_message_typeContext) AllId

func (*Alter_message_typeContext) COLLECTION

func (*Alter_message_typeContext) EMPTY

func (*Alter_message_typeContext) EQUAL

func (*Alter_message_typeContext) EnterRule

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

func (*Alter_message_typeContext) ExitRule

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

func (*Alter_message_typeContext) GetMessage_type_name

func (s *Alter_message_typeContext) GetMessage_type_name() IIdContext

func (*Alter_message_typeContext) GetParser

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

func (*Alter_message_typeContext) GetRuleContext

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

func (*Alter_message_typeContext) GetSchema_collection_name

func (s *Alter_message_typeContext) GetSchema_collection_name() IIdContext

func (*Alter_message_typeContext) Id

func (*Alter_message_typeContext) IsAlter_message_typeContext

func (*Alter_message_typeContext) IsAlter_message_typeContext()

func (*Alter_message_typeContext) MESSAGE

func (*Alter_message_typeContext) NONE

func (*Alter_message_typeContext) SCHEMA

func (*Alter_message_typeContext) SetMessage_type_name

func (s *Alter_message_typeContext) SetMessage_type_name(v IIdContext)

func (*Alter_message_typeContext) SetSchema_collection_name

func (s *Alter_message_typeContext) SetSchema_collection_name(v IIdContext)

func (*Alter_message_typeContext) TYPE

func (*Alter_message_typeContext) ToStringTree

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

func (*Alter_message_typeContext) VALIDATION

func (*Alter_message_typeContext) VALID_XML

func (*Alter_message_typeContext) WELL_FORMED_XML

func (s *Alter_message_typeContext) WELL_FORMED_XML() antlr.TerminalNode

func (*Alter_message_typeContext) WITH

type Alter_partition_functionContext

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

func NewAlter_partition_functionContext

func NewAlter_partition_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_partition_functionContext

func NewEmptyAlter_partition_functionContext

func NewEmptyAlter_partition_functionContext() *Alter_partition_functionContext

func (*Alter_partition_functionContext) ALTER

func (*Alter_partition_functionContext) AllLR_BRACKET

func (s *Alter_partition_functionContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Alter_partition_functionContext) AllRR_BRACKET

func (s *Alter_partition_functionContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Alter_partition_functionContext) DECIMAL

func (*Alter_partition_functionContext) EnterRule

func (*Alter_partition_functionContext) ExitRule

func (*Alter_partition_functionContext) FUNCTION

func (*Alter_partition_functionContext) GetParser

func (*Alter_partition_functionContext) GetPartition_function_name

func (s *Alter_partition_functionContext) GetPartition_function_name() IIdContext

func (*Alter_partition_functionContext) GetRuleContext

func (*Alter_partition_functionContext) Id

func (*Alter_partition_functionContext) IsAlter_partition_functionContext

func (*Alter_partition_functionContext) IsAlter_partition_functionContext()

func (*Alter_partition_functionContext) LR_BRACKET

func (*Alter_partition_functionContext) MERGE

func (*Alter_partition_functionContext) PARTITION

func (*Alter_partition_functionContext) RANGE

func (*Alter_partition_functionContext) RR_BRACKET

func (*Alter_partition_functionContext) SPLIT

func (*Alter_partition_functionContext) SetPartition_function_name

func (s *Alter_partition_functionContext) SetPartition_function_name(v IIdContext)

func (*Alter_partition_functionContext) ToStringTree

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

type Alter_partition_schemeContext

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

func NewAlter_partition_schemeContext

func NewAlter_partition_schemeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_partition_schemeContext

func NewEmptyAlter_partition_schemeContext

func NewEmptyAlter_partition_schemeContext() *Alter_partition_schemeContext

func (*Alter_partition_schemeContext) ALTER

func (*Alter_partition_schemeContext) AllId

func (*Alter_partition_schemeContext) EnterRule

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

func (*Alter_partition_schemeContext) ExitRule

func (*Alter_partition_schemeContext) GetFile_group_name

func (s *Alter_partition_schemeContext) GetFile_group_name() IIdContext

func (*Alter_partition_schemeContext) GetParser

func (*Alter_partition_schemeContext) GetPartition_scheme_name

func (s *Alter_partition_schemeContext) GetPartition_scheme_name() IIdContext

func (*Alter_partition_schemeContext) GetRuleContext

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

func (*Alter_partition_schemeContext) Id

func (*Alter_partition_schemeContext) IsAlter_partition_schemeContext

func (*Alter_partition_schemeContext) IsAlter_partition_schemeContext()

func (*Alter_partition_schemeContext) NEXT

func (*Alter_partition_schemeContext) PARTITION

func (*Alter_partition_schemeContext) SCHEME

func (*Alter_partition_schemeContext) SetFile_group_name

func (s *Alter_partition_schemeContext) SetFile_group_name(v IIdContext)

func (*Alter_partition_schemeContext) SetPartition_scheme_name

func (s *Alter_partition_schemeContext) SetPartition_scheme_name(v IIdContext)

func (*Alter_partition_schemeContext) ToStringTree

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

func (*Alter_partition_schemeContext) USED

type Alter_queueContext

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

func NewAlter_queueContext

func NewAlter_queueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_queueContext

func NewEmptyAlter_queueContext

func NewEmptyAlter_queueContext() *Alter_queueContext

func (*Alter_queueContext) ALTER

func (*Alter_queueContext) EnterRule

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

func (*Alter_queueContext) ExitRule

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

func (*Alter_queueContext) Full_table_name

func (s *Alter_queueContext) Full_table_name() IFull_table_nameContext

func (*Alter_queueContext) GetParser

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

func (*Alter_queueContext) GetQueue_name

func (s *Alter_queueContext) GetQueue_name() IIdContext

func (*Alter_queueContext) GetRuleContext

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

func (*Alter_queueContext) Id

func (*Alter_queueContext) IsAlter_queueContext

func (*Alter_queueContext) IsAlter_queueContext()

func (*Alter_queueContext) QUEUE

func (*Alter_queueContext) Queue_action

func (s *Alter_queueContext) Queue_action() IQueue_actionContext

func (*Alter_queueContext) Queue_settings

func (s *Alter_queueContext) Queue_settings() IQueue_settingsContext

func (*Alter_queueContext) SetQueue_name

func (s *Alter_queueContext) SetQueue_name(v IIdContext)

func (*Alter_queueContext) ToStringTree

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

type Alter_remote_service_bindingContext

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

func NewAlter_remote_service_bindingContext

func NewAlter_remote_service_bindingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_remote_service_bindingContext

func NewEmptyAlter_remote_service_bindingContext

func NewEmptyAlter_remote_service_bindingContext() *Alter_remote_service_bindingContext

func (*Alter_remote_service_bindingContext) ALTER

func (*Alter_remote_service_bindingContext) ANONYMOUS

func (*Alter_remote_service_bindingContext) AllEQUAL

func (*Alter_remote_service_bindingContext) AllId

func (*Alter_remote_service_bindingContext) BINDING

func (*Alter_remote_service_bindingContext) COMMA

func (*Alter_remote_service_bindingContext) EQUAL

func (*Alter_remote_service_bindingContext) EnterRule

func (*Alter_remote_service_bindingContext) ExitRule

func (*Alter_remote_service_bindingContext) GetBinding_name

func (s *Alter_remote_service_bindingContext) GetBinding_name() IIdContext

func (*Alter_remote_service_bindingContext) GetParser

func (*Alter_remote_service_bindingContext) GetRuleContext

func (*Alter_remote_service_bindingContext) GetUser_name

func (*Alter_remote_service_bindingContext) Id

func (*Alter_remote_service_bindingContext) IsAlter_remote_service_bindingContext

func (*Alter_remote_service_bindingContext) IsAlter_remote_service_bindingContext()

func (*Alter_remote_service_bindingContext) OFF

func (*Alter_remote_service_bindingContext) ON

func (*Alter_remote_service_bindingContext) REMOTE

func (*Alter_remote_service_bindingContext) SERVICE

func (*Alter_remote_service_bindingContext) SetBinding_name

func (s *Alter_remote_service_bindingContext) SetBinding_name(v IIdContext)

func (*Alter_remote_service_bindingContext) SetUser_name

func (*Alter_remote_service_bindingContext) ToStringTree

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

func (*Alter_remote_service_bindingContext) USER

func (*Alter_remote_service_bindingContext) WITH

type Alter_resource_governorContext

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

func NewAlter_resource_governorContext

func NewAlter_resource_governorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_resource_governorContext

func NewEmptyAlter_resource_governorContext

func NewEmptyAlter_resource_governorContext() *Alter_resource_governorContext

func (*Alter_resource_governorContext) ALTER

func (*Alter_resource_governorContext) AllId

func (*Alter_resource_governorContext) CLASSIFIER_FUNCTION

func (s *Alter_resource_governorContext) CLASSIFIER_FUNCTION() antlr.TerminalNode

func (*Alter_resource_governorContext) DECIMAL

func (*Alter_resource_governorContext) DISABLE

func (*Alter_resource_governorContext) DOT

func (*Alter_resource_governorContext) EQUAL

func (*Alter_resource_governorContext) EnterRule

func (*Alter_resource_governorContext) ExitRule

func (*Alter_resource_governorContext) GOVERNOR

func (*Alter_resource_governorContext) GetFunction_name

func (s *Alter_resource_governorContext) GetFunction_name() IIdContext

func (*Alter_resource_governorContext) GetMax_outstanding_io_per_volume

func (s *Alter_resource_governorContext) GetMax_outstanding_io_per_volume() antlr.Token

func (*Alter_resource_governorContext) GetParser

func (*Alter_resource_governorContext) GetRuleContext

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

func (*Alter_resource_governorContext) GetSchema_name

func (s *Alter_resource_governorContext) GetSchema_name() IIdContext

func (*Alter_resource_governorContext) Id

func (*Alter_resource_governorContext) IsAlter_resource_governorContext

func (*Alter_resource_governorContext) IsAlter_resource_governorContext()

func (*Alter_resource_governorContext) LR_BRACKET

func (*Alter_resource_governorContext) MAX_OUTSTANDING_IO_PER_VOLUME

func (s *Alter_resource_governorContext) MAX_OUTSTANDING_IO_PER_VOLUME() antlr.TerminalNode

func (*Alter_resource_governorContext) NULL

func (*Alter_resource_governorContext) RECONFIGURE

func (*Alter_resource_governorContext) RESET

func (*Alter_resource_governorContext) RESOURCE

func (*Alter_resource_governorContext) RR_BRACKET

func (*Alter_resource_governorContext) STATISTICS

func (*Alter_resource_governorContext) SetFunction_name

func (s *Alter_resource_governorContext) SetFunction_name(v IIdContext)

func (*Alter_resource_governorContext) SetMax_outstanding_io_per_volume

func (s *Alter_resource_governorContext) SetMax_outstanding_io_per_volume(v antlr.Token)

func (*Alter_resource_governorContext) SetSchema_name

func (s *Alter_resource_governorContext) SetSchema_name(v IIdContext)

func (*Alter_resource_governorContext) ToStringTree

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

func (*Alter_resource_governorContext) WITH

type Alter_schema_azure_sql_dw_and_pdwContext

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

func NewAlter_schema_azure_sql_dw_and_pdwContext

func NewAlter_schema_azure_sql_dw_and_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_schema_azure_sql_dw_and_pdwContext

func NewEmptyAlter_schema_azure_sql_dw_and_pdwContext

func NewEmptyAlter_schema_azure_sql_dw_and_pdwContext() *Alter_schema_azure_sql_dw_and_pdwContext

func (*Alter_schema_azure_sql_dw_and_pdwContext) ALTER

func (*Alter_schema_azure_sql_dw_and_pdwContext) AllCOLON

func (*Alter_schema_azure_sql_dw_and_pdwContext) AllId

func (*Alter_schema_azure_sql_dw_and_pdwContext) COLON

func (*Alter_schema_azure_sql_dw_and_pdwContext) DOT

func (*Alter_schema_azure_sql_dw_and_pdwContext) EnterRule

func (*Alter_schema_azure_sql_dw_and_pdwContext) ExitRule

func (*Alter_schema_azure_sql_dw_and_pdwContext) GetParser

func (*Alter_schema_azure_sql_dw_and_pdwContext) GetRuleContext

func (*Alter_schema_azure_sql_dw_and_pdwContext) GetSchema_name

func (*Alter_schema_azure_sql_dw_and_pdwContext) ID

func (*Alter_schema_azure_sql_dw_and_pdwContext) Id

func (*Alter_schema_azure_sql_dw_and_pdwContext) IsAlter_schema_azure_sql_dw_and_pdwContext

func (*Alter_schema_azure_sql_dw_and_pdwContext) IsAlter_schema_azure_sql_dw_and_pdwContext()

func (*Alter_schema_azure_sql_dw_and_pdwContext) OBJECT

func (*Alter_schema_azure_sql_dw_and_pdwContext) SCHEMA

func (*Alter_schema_azure_sql_dw_and_pdwContext) SetSchema_name

func (*Alter_schema_azure_sql_dw_and_pdwContext) TRANSFER

func (*Alter_schema_azure_sql_dw_and_pdwContext) ToStringTree

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

type Alter_schema_sqlContext

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

func NewAlter_schema_sqlContext

func NewAlter_schema_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_schema_sqlContext

func NewEmptyAlter_schema_sqlContext

func NewEmptyAlter_schema_sqlContext() *Alter_schema_sqlContext

func (*Alter_schema_sqlContext) ALTER

func (*Alter_schema_sqlContext) AllCOLON

func (s *Alter_schema_sqlContext) AllCOLON() []antlr.TerminalNode

func (*Alter_schema_sqlContext) AllId

func (s *Alter_schema_sqlContext) AllId() []IIdContext

func (*Alter_schema_sqlContext) AllSCHEMA

func (s *Alter_schema_sqlContext) AllSCHEMA() []antlr.TerminalNode

func (*Alter_schema_sqlContext) COLLECTION

func (s *Alter_schema_sqlContext) COLLECTION() antlr.TerminalNode

func (*Alter_schema_sqlContext) COLON

func (*Alter_schema_sqlContext) DOT

func (*Alter_schema_sqlContext) EnterRule

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

func (*Alter_schema_sqlContext) ExitRule

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

func (*Alter_schema_sqlContext) GetParser

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

func (*Alter_schema_sqlContext) GetRuleContext

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

func (*Alter_schema_sqlContext) GetSchema_name

func (s *Alter_schema_sqlContext) GetSchema_name() IIdContext

func (*Alter_schema_sqlContext) Id

func (*Alter_schema_sqlContext) IsAlter_schema_sqlContext

func (*Alter_schema_sqlContext) IsAlter_schema_sqlContext()

func (*Alter_schema_sqlContext) OBJECT

func (*Alter_schema_sqlContext) SCHEMA

func (*Alter_schema_sqlContext) SetSchema_name

func (s *Alter_schema_sqlContext) SetSchema_name(v IIdContext)

func (*Alter_schema_sqlContext) TRANSFER

func (*Alter_schema_sqlContext) TYPE

func (*Alter_schema_sqlContext) ToStringTree

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

func (*Alter_schema_sqlContext) XML

type Alter_sequenceContext

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

func NewAlter_sequenceContext

func NewAlter_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_sequenceContext

func NewEmptyAlter_sequenceContext

func NewEmptyAlter_sequenceContext() *Alter_sequenceContext

func (*Alter_sequenceContext) ALTER

func (*Alter_sequenceContext) AllDECIMAL

func (s *Alter_sequenceContext) AllDECIMAL() []antlr.TerminalNode

func (*Alter_sequenceContext) AllId

func (s *Alter_sequenceContext) AllId() []IIdContext

func (*Alter_sequenceContext) AllNO

func (*Alter_sequenceContext) BY

func (*Alter_sequenceContext) CACHE

func (*Alter_sequenceContext) CYCLE

func (*Alter_sequenceContext) DECIMAL

func (*Alter_sequenceContext) DOT

func (*Alter_sequenceContext) EnterRule

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

func (*Alter_sequenceContext) ExitRule

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

func (*Alter_sequenceContext) GetParser

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

func (*Alter_sequenceContext) GetRuleContext

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

func (*Alter_sequenceContext) GetSchema_name

func (s *Alter_sequenceContext) GetSchema_name() IIdContext

func (*Alter_sequenceContext) GetSequence_name

func (s *Alter_sequenceContext) GetSequence_name() IIdContext

func (*Alter_sequenceContext) GetSequnce_increment

func (s *Alter_sequenceContext) GetSequnce_increment() antlr.Token

func (*Alter_sequenceContext) INCREMENT

func (s *Alter_sequenceContext) INCREMENT() antlr.TerminalNode

func (*Alter_sequenceContext) Id

func (*Alter_sequenceContext) IsAlter_sequenceContext

func (*Alter_sequenceContext) IsAlter_sequenceContext()

func (*Alter_sequenceContext) MAXVALUE

func (*Alter_sequenceContext) MINVALUE

func (*Alter_sequenceContext) NO

func (*Alter_sequenceContext) RESTART

func (*Alter_sequenceContext) SEQUENCE

func (*Alter_sequenceContext) SetSchema_name

func (s *Alter_sequenceContext) SetSchema_name(v IIdContext)

func (*Alter_sequenceContext) SetSequence_name

func (s *Alter_sequenceContext) SetSequence_name(v IIdContext)

func (*Alter_sequenceContext) SetSequnce_increment

func (s *Alter_sequenceContext) SetSequnce_increment(v antlr.Token)

func (*Alter_sequenceContext) ToStringTree

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

func (*Alter_sequenceContext) WITH

type Alter_server_auditContext

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

func NewAlter_server_auditContext

func NewAlter_server_auditContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_server_auditContext

func NewEmptyAlter_server_auditContext

func NewEmptyAlter_server_auditContext() *Alter_server_auditContext

func (*Alter_server_auditContext) ALTER

func (*Alter_server_auditContext) AND

func (*Alter_server_auditContext) APPLICATION_LOG

func (s *Alter_server_auditContext) APPLICATION_LOG() antlr.TerminalNode

func (*Alter_server_auditContext) AUDIT

func (*Alter_server_auditContext) AllCOMMA

func (*Alter_server_auditContext) AllCONTINUE

func (s *Alter_server_auditContext) AllCONTINUE() []antlr.TerminalNode

func (*Alter_server_auditContext) AllDECIMAL

func (s *Alter_server_auditContext) AllDECIMAL() []antlr.TerminalNode

func (*Alter_server_auditContext) AllEQUAL

func (*Alter_server_auditContext) AllFAIL_OPERATION

func (s *Alter_server_auditContext) AllFAIL_OPERATION() []antlr.TerminalNode

func (*Alter_server_auditContext) AllFILEPATH

func (s *Alter_server_auditContext) AllFILEPATH() []antlr.TerminalNode

func (*Alter_server_auditContext) AllGB

func (*Alter_server_auditContext) AllId

func (*Alter_server_auditContext) AllLR_BRACKET

func (s *Alter_server_auditContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Alter_server_auditContext) AllMAXSIZE

func (s *Alter_server_auditContext) AllMAXSIZE() []antlr.TerminalNode

func (*Alter_server_auditContext) AllMAX_FILES

func (s *Alter_server_auditContext) AllMAX_FILES() []antlr.TerminalNode

func (*Alter_server_auditContext) AllMAX_ROLLOVER_FILES

func (s *Alter_server_auditContext) AllMAX_ROLLOVER_FILES() []antlr.TerminalNode

func (*Alter_server_auditContext) AllMB

func (*Alter_server_auditContext) AllOFF

func (*Alter_server_auditContext) AllON

func (*Alter_server_auditContext) AllON_FAILURE

func (s *Alter_server_auditContext) AllON_FAILURE() []antlr.TerminalNode

func (*Alter_server_auditContext) AllQUEUE_DELAY

func (s *Alter_server_auditContext) AllQUEUE_DELAY() []antlr.TerminalNode

func (*Alter_server_auditContext) AllRESERVE_DISK_SPACE

func (s *Alter_server_auditContext) AllRESERVE_DISK_SPACE() []antlr.TerminalNode

func (*Alter_server_auditContext) AllRR_BRACKET

func (s *Alter_server_auditContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Alter_server_auditContext) AllSHUTDOWN

func (s *Alter_server_auditContext) AllSHUTDOWN() []antlr.TerminalNode

func (*Alter_server_auditContext) AllSTATE

func (*Alter_server_auditContext) AllSTRING

func (s *Alter_server_auditContext) AllSTRING() []antlr.TerminalNode

func (*Alter_server_auditContext) AllTB

func (*Alter_server_auditContext) AllUNLIMITED

func (s *Alter_server_auditContext) AllUNLIMITED() []antlr.TerminalNode

func (*Alter_server_auditContext) COMMA

func (*Alter_server_auditContext) CONTINUE

func (*Alter_server_auditContext) DECIMAL

func (*Alter_server_auditContext) EQUAL

func (*Alter_server_auditContext) EXCLAMATION

func (s *Alter_server_auditContext) EXCLAMATION() antlr.TerminalNode

func (*Alter_server_auditContext) EnterRule

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

func (*Alter_server_auditContext) ExitRule

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

func (*Alter_server_auditContext) FAIL_OPERATION

func (s *Alter_server_auditContext) FAIL_OPERATION(i int) antlr.TerminalNode

func (*Alter_server_auditContext) FILE

func (*Alter_server_auditContext) FILEPATH

func (*Alter_server_auditContext) GB

func (*Alter_server_auditContext) GREATER

func (*Alter_server_auditContext) GetAudit_name

func (s *Alter_server_auditContext) GetAudit_name() IIdContext

func (*Alter_server_auditContext) GetEvent_field_name

func (s *Alter_server_auditContext) GetEvent_field_name() IIdContext

func (*Alter_server_auditContext) GetFilepath

func (s *Alter_server_auditContext) GetFilepath() antlr.Token

func (*Alter_server_auditContext) GetMax_files

func (s *Alter_server_auditContext) GetMax_files() antlr.Token

func (*Alter_server_auditContext) GetMax_rollover_files

func (s *Alter_server_auditContext) GetMax_rollover_files() antlr.Token

func (*Alter_server_auditContext) GetNew_audit_name

func (s *Alter_server_auditContext) GetNew_audit_name() IIdContext

func (*Alter_server_auditContext) GetParser

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

func (*Alter_server_auditContext) GetQueue_delay

func (s *Alter_server_auditContext) GetQueue_delay() antlr.Token

func (*Alter_server_auditContext) GetRuleContext

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

func (*Alter_server_auditContext) Id

func (*Alter_server_auditContext) IsAlter_server_auditContext

func (*Alter_server_auditContext) IsAlter_server_auditContext()

func (*Alter_server_auditContext) LESS

func (*Alter_server_auditContext) LR_BRACKET

func (*Alter_server_auditContext) MAXSIZE

func (*Alter_server_auditContext) MAX_FILES

func (*Alter_server_auditContext) MAX_ROLLOVER_FILES

func (s *Alter_server_auditContext) MAX_ROLLOVER_FILES(i int) antlr.TerminalNode

func (*Alter_server_auditContext) MB

func (*Alter_server_auditContext) MODIFY

func (*Alter_server_auditContext) NAME

func (*Alter_server_auditContext) NOT

func (*Alter_server_auditContext) OFF

func (*Alter_server_auditContext) ON

func (*Alter_server_auditContext) ON_FAILURE

func (*Alter_server_auditContext) OR

func (*Alter_server_auditContext) QUEUE_DELAY

func (s *Alter_server_auditContext) QUEUE_DELAY(i int) antlr.TerminalNode

func (*Alter_server_auditContext) REMOVE

func (*Alter_server_auditContext) RESERVE_DISK_SPACE

func (s *Alter_server_auditContext) RESERVE_DISK_SPACE(i int) antlr.TerminalNode

func (*Alter_server_auditContext) RR_BRACKET

func (*Alter_server_auditContext) SECURITY_LOG

func (s *Alter_server_auditContext) SECURITY_LOG() antlr.TerminalNode

func (*Alter_server_auditContext) SERVER

func (*Alter_server_auditContext) SHUTDOWN

func (*Alter_server_auditContext) STATE

func (*Alter_server_auditContext) STRING

func (*Alter_server_auditContext) SetAudit_name

func (s *Alter_server_auditContext) SetAudit_name(v IIdContext)

func (*Alter_server_auditContext) SetEvent_field_name

func (s *Alter_server_auditContext) SetEvent_field_name(v IIdContext)

func (*Alter_server_auditContext) SetFilepath

func (s *Alter_server_auditContext) SetFilepath(v antlr.Token)

func (*Alter_server_auditContext) SetMax_files

func (s *Alter_server_auditContext) SetMax_files(v antlr.Token)

func (*Alter_server_auditContext) SetMax_rollover_files

func (s *Alter_server_auditContext) SetMax_rollover_files(v antlr.Token)

func (*Alter_server_auditContext) SetNew_audit_name

func (s *Alter_server_auditContext) SetNew_audit_name(v IIdContext)

func (*Alter_server_auditContext) SetQueue_delay

func (s *Alter_server_auditContext) SetQueue_delay(v antlr.Token)

func (*Alter_server_auditContext) TB

func (*Alter_server_auditContext) TO

func (*Alter_server_auditContext) ToStringTree

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

func (*Alter_server_auditContext) UNLIMITED

func (*Alter_server_auditContext) WHERE

func (*Alter_server_auditContext) WITH

type Alter_server_audit_specificationContext

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

func NewAlter_server_audit_specificationContext

func NewAlter_server_audit_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_server_audit_specificationContext

func NewEmptyAlter_server_audit_specificationContext

func NewEmptyAlter_server_audit_specificationContext() *Alter_server_audit_specificationContext

func (*Alter_server_audit_specificationContext) ADD

func (*Alter_server_audit_specificationContext) ALTER

func (*Alter_server_audit_specificationContext) AUDIT

func (*Alter_server_audit_specificationContext) AllADD

func (*Alter_server_audit_specificationContext) AllAUDIT

func (*Alter_server_audit_specificationContext) AllDROP

func (*Alter_server_audit_specificationContext) AllId

func (*Alter_server_audit_specificationContext) AllLR_BRACKET

func (*Alter_server_audit_specificationContext) AllRR_BRACKET

func (*Alter_server_audit_specificationContext) AllSERVER

func (*Alter_server_audit_specificationContext) DROP

func (*Alter_server_audit_specificationContext) EQUAL

func (*Alter_server_audit_specificationContext) EnterRule

func (*Alter_server_audit_specificationContext) ExitRule

func (*Alter_server_audit_specificationContext) FOR

func (*Alter_server_audit_specificationContext) GetAudit_action_group_name

func (s *Alter_server_audit_specificationContext) GetAudit_action_group_name() IIdContext

func (*Alter_server_audit_specificationContext) GetAudit_name

func (*Alter_server_audit_specificationContext) GetAudit_specification_name

func (s *Alter_server_audit_specificationContext) GetAudit_specification_name() IIdContext

func (*Alter_server_audit_specificationContext) GetParser

func (*Alter_server_audit_specificationContext) GetRuleContext

func (*Alter_server_audit_specificationContext) Id

func (*Alter_server_audit_specificationContext) IsAlter_server_audit_specificationContext

func (*Alter_server_audit_specificationContext) IsAlter_server_audit_specificationContext()

func (*Alter_server_audit_specificationContext) LR_BRACKET

func (*Alter_server_audit_specificationContext) OFF

func (*Alter_server_audit_specificationContext) ON

func (*Alter_server_audit_specificationContext) RR_BRACKET

func (*Alter_server_audit_specificationContext) SERVER

func (*Alter_server_audit_specificationContext) SPECIFICATION

func (*Alter_server_audit_specificationContext) STATE

func (*Alter_server_audit_specificationContext) SetAudit_action_group_name

func (s *Alter_server_audit_specificationContext) SetAudit_action_group_name(v IIdContext)

func (*Alter_server_audit_specificationContext) SetAudit_name

func (*Alter_server_audit_specificationContext) SetAudit_specification_name

func (s *Alter_server_audit_specificationContext) SetAudit_specification_name(v IIdContext)

func (*Alter_server_audit_specificationContext) ToStringTree

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

func (*Alter_server_audit_specificationContext) WITH

type Alter_server_configurationContext

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

func NewAlter_server_configurationContext

func NewAlter_server_configurationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_server_configurationContext

func NewEmptyAlter_server_configurationContext

func NewEmptyAlter_server_configurationContext() *Alter_server_configurationContext

func (*Alter_server_configurationContext) AFFINITY

func (*Alter_server_configurationContext) ALTER

func (*Alter_server_configurationContext) AUTO

func (*Alter_server_configurationContext) AllCOMMA

func (*Alter_server_configurationContext) AllDECIMAL

func (*Alter_server_configurationContext) AllEQUAL

func (*Alter_server_configurationContext) AllSET

func (*Alter_server_configurationContext) AllTO

func (*Alter_server_configurationContext) BUFFER

func (*Alter_server_configurationContext) CLUSTER

func (*Alter_server_configurationContext) COMMA

func (*Alter_server_configurationContext) CONFIGURATION

func (*Alter_server_configurationContext) CONTEXT

func (*Alter_server_configurationContext) CPU

func (*Alter_server_configurationContext) DECIMAL

func (*Alter_server_configurationContext) DEFAULT

func (*Alter_server_configurationContext) DIAGNOSTICS

func (*Alter_server_configurationContext) EQUAL

func (*Alter_server_configurationContext) EXTENSION

func (*Alter_server_configurationContext) EnterRule

func (*Alter_server_configurationContext) ExitRule

func (*Alter_server_configurationContext) FAILOVER

func (*Alter_server_configurationContext) FAILURECONDITIONLEVEL

func (s *Alter_server_configurationContext) FAILURECONDITIONLEVEL() antlr.TerminalNode

func (*Alter_server_configurationContext) FILENAME

func (*Alter_server_configurationContext) GB

func (*Alter_server_configurationContext) GetParser

func (*Alter_server_configurationContext) GetRuleContext

func (*Alter_server_configurationContext) HADR

func (*Alter_server_configurationContext) HEALTHCHECKTIMEOUT

func (s *Alter_server_configurationContext) HEALTHCHECKTIMEOUT() antlr.TerminalNode

func (*Alter_server_configurationContext) IsAlter_server_configurationContext

func (*Alter_server_configurationContext) IsAlter_server_configurationContext()

func (*Alter_server_configurationContext) KB

func (*Alter_server_configurationContext) LOCAL

func (*Alter_server_configurationContext) LOG

func (*Alter_server_configurationContext) LR_BRACKET

func (*Alter_server_configurationContext) MAX_FILES

func (*Alter_server_configurationContext) MAX_SIZE

func (*Alter_server_configurationContext) MB

func (*Alter_server_configurationContext) NUMANODE

func (*Alter_server_configurationContext) OFF

func (*Alter_server_configurationContext) ON

func (*Alter_server_configurationContext) PATH

func (*Alter_server_configurationContext) POOL

func (*Alter_server_configurationContext) PROCESS

func (*Alter_server_configurationContext) PROPERTY

func (*Alter_server_configurationContext) RR_BRACKET

func (*Alter_server_configurationContext) SERVER

func (*Alter_server_configurationContext) SET

func (*Alter_server_configurationContext) SIZE

func (*Alter_server_configurationContext) SOFTNUMA

func (*Alter_server_configurationContext) SQLDUMPERFLAGS

func (*Alter_server_configurationContext) SQLDUMPERPATH

func (*Alter_server_configurationContext) SQLDUMPERTIMEOUT

func (*Alter_server_configurationContext) STRING

func (*Alter_server_configurationContext) TO

func (*Alter_server_configurationContext) ToStringTree

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

func (*Alter_server_configurationContext) VERBOSELOGGING

type Alter_server_roleContext

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

func NewAlter_server_roleContext

func NewAlter_server_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_server_roleContext

func NewEmptyAlter_server_roleContext

func NewEmptyAlter_server_roleContext() *Alter_server_roleContext

func (*Alter_server_roleContext) ADD

func (*Alter_server_roleContext) ALTER

func (*Alter_server_roleContext) AllId

func (s *Alter_server_roleContext) AllId() []IIdContext

func (*Alter_server_roleContext) DROP

func (*Alter_server_roleContext) EQUAL

func (*Alter_server_roleContext) EnterRule

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

func (*Alter_server_roleContext) ExitRule

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

func (*Alter_server_roleContext) GetNew_server_role_name

func (s *Alter_server_roleContext) GetNew_server_role_name() IIdContext

func (*Alter_server_roleContext) GetParser

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

func (*Alter_server_roleContext) GetRuleContext

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

func (*Alter_server_roleContext) GetServer_principal

func (s *Alter_server_roleContext) GetServer_principal() IIdContext

func (*Alter_server_roleContext) GetServer_role_name

func (s *Alter_server_roleContext) GetServer_role_name() IIdContext

func (*Alter_server_roleContext) Id

func (*Alter_server_roleContext) IsAlter_server_roleContext

func (*Alter_server_roleContext) IsAlter_server_roleContext()

func (*Alter_server_roleContext) MEMBER

func (*Alter_server_roleContext) NAME

func (*Alter_server_roleContext) ROLE

func (*Alter_server_roleContext) SERVER

func (*Alter_server_roleContext) SetNew_server_role_name

func (s *Alter_server_roleContext) SetNew_server_role_name(v IIdContext)

func (*Alter_server_roleContext) SetServer_principal

func (s *Alter_server_roleContext) SetServer_principal(v IIdContext)

func (*Alter_server_roleContext) SetServer_role_name

func (s *Alter_server_roleContext) SetServer_role_name(v IIdContext)

func (*Alter_server_roleContext) ToStringTree

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

func (*Alter_server_roleContext) WITH

type Alter_server_role_pdwContext

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

func NewAlter_server_role_pdwContext

func NewAlter_server_role_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_server_role_pdwContext

func NewEmptyAlter_server_role_pdwContext

func NewEmptyAlter_server_role_pdwContext() *Alter_server_role_pdwContext

func (*Alter_server_role_pdwContext) ADD

func (*Alter_server_role_pdwContext) ALTER

func (*Alter_server_role_pdwContext) AllId

func (*Alter_server_role_pdwContext) DROP

func (*Alter_server_role_pdwContext) EnterRule

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

func (*Alter_server_role_pdwContext) ExitRule

func (*Alter_server_role_pdwContext) GetLogin

func (*Alter_server_role_pdwContext) GetParser

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

func (*Alter_server_role_pdwContext) GetRuleContext

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

func (*Alter_server_role_pdwContext) GetServer_role_name

func (s *Alter_server_role_pdwContext) GetServer_role_name() IIdContext

func (*Alter_server_role_pdwContext) Id

func (*Alter_server_role_pdwContext) IsAlter_server_role_pdwContext

func (*Alter_server_role_pdwContext) IsAlter_server_role_pdwContext()

func (*Alter_server_role_pdwContext) MEMBER

func (*Alter_server_role_pdwContext) ROLE

func (*Alter_server_role_pdwContext) SERVER

func (*Alter_server_role_pdwContext) SetLogin

func (*Alter_server_role_pdwContext) SetServer_role_name

func (s *Alter_server_role_pdwContext) SetServer_role_name(v IIdContext)

func (*Alter_server_role_pdwContext) ToStringTree

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

type Alter_serviceContext

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

func NewAlter_serviceContext

func NewAlter_serviceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_serviceContext

func NewEmptyAlter_serviceContext

func NewEmptyAlter_serviceContext() *Alter_serviceContext

func (*Alter_serviceContext) ADD

func (*Alter_serviceContext) ALTER

func (*Alter_serviceContext) AllADD

func (s *Alter_serviceContext) AllADD() []antlr.TerminalNode

func (*Alter_serviceContext) AllCOMMA

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

func (*Alter_serviceContext) AllDROP

func (s *Alter_serviceContext) AllDROP() []antlr.TerminalNode

func (*Alter_serviceContext) AllId

func (s *Alter_serviceContext) AllId() []IIdContext

func (*Alter_serviceContext) COMMA

func (*Alter_serviceContext) DOT

func (*Alter_serviceContext) DROP

func (*Alter_serviceContext) EnterRule

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

func (*Alter_serviceContext) ExitRule

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

func (*Alter_serviceContext) GetModified_contract_name

func (s *Alter_serviceContext) GetModified_contract_name() IIdContext

func (*Alter_serviceContext) GetModified_service_name

func (s *Alter_serviceContext) GetModified_service_name() IIdContext

func (*Alter_serviceContext) GetParser

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

func (*Alter_serviceContext) GetQueue_name

func (s *Alter_serviceContext) GetQueue_name() IIdContext

func (*Alter_serviceContext) GetRuleContext

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

func (*Alter_serviceContext) GetSchema_name

func (s *Alter_serviceContext) GetSchema_name() IIdContext

func (*Alter_serviceContext) Id

func (*Alter_serviceContext) IsAlter_serviceContext

func (*Alter_serviceContext) IsAlter_serviceContext()

func (*Alter_serviceContext) ON

func (*Alter_serviceContext) QUEUE

func (*Alter_serviceContext) SERVICE

func (*Alter_serviceContext) SetModified_contract_name

func (s *Alter_serviceContext) SetModified_contract_name(v IIdContext)

func (*Alter_serviceContext) SetModified_service_name

func (s *Alter_serviceContext) SetModified_service_name(v IIdContext)

func (*Alter_serviceContext) SetQueue_name

func (s *Alter_serviceContext) SetQueue_name(v IIdContext)

func (*Alter_serviceContext) SetSchema_name

func (s *Alter_serviceContext) SetSchema_name(v IIdContext)

func (*Alter_serviceContext) ToStringTree

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

type Alter_service_master_keyContext

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

func NewAlter_service_master_keyContext

func NewAlter_service_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_service_master_keyContext

func NewEmptyAlter_service_master_keyContext

func NewEmptyAlter_service_master_keyContext() *Alter_service_master_keyContext

func (*Alter_service_master_keyContext) ALTER

func (*Alter_service_master_keyContext) AllEQUAL

func (*Alter_service_master_keyContext) AllSTRING

func (*Alter_service_master_keyContext) COMMA

func (*Alter_service_master_keyContext) EQUAL

func (*Alter_service_master_keyContext) EnterRule

func (*Alter_service_master_keyContext) ExitRule

func (*Alter_service_master_keyContext) FORCE

func (*Alter_service_master_keyContext) GetAcold_account_name

func (s *Alter_service_master_keyContext) GetAcold_account_name() antlr.Token

func (*Alter_service_master_keyContext) GetNew_account_name

func (s *Alter_service_master_keyContext) GetNew_account_name() antlr.Token

func (*Alter_service_master_keyContext) GetNew_password

func (s *Alter_service_master_keyContext) GetNew_password() antlr.Token

func (*Alter_service_master_keyContext) GetOld_password

func (s *Alter_service_master_keyContext) GetOld_password() antlr.Token

func (*Alter_service_master_keyContext) GetParser

func (*Alter_service_master_keyContext) GetRuleContext

func (*Alter_service_master_keyContext) IsAlter_service_master_keyContext

func (*Alter_service_master_keyContext) IsAlter_service_master_keyContext()

func (*Alter_service_master_keyContext) KEY

func (*Alter_service_master_keyContext) MASTER

func (*Alter_service_master_keyContext) NEW_ACCOUNT

func (*Alter_service_master_keyContext) NEW_PASSWORD

func (*Alter_service_master_keyContext) OLD_ACCOUNT

func (*Alter_service_master_keyContext) OLD_PASSWORD

func (*Alter_service_master_keyContext) REGENERATE

func (*Alter_service_master_keyContext) SERVICE

func (*Alter_service_master_keyContext) STRING

func (*Alter_service_master_keyContext) SetAcold_account_name

func (s *Alter_service_master_keyContext) SetAcold_account_name(v antlr.Token)

func (*Alter_service_master_keyContext) SetNew_account_name

func (s *Alter_service_master_keyContext) SetNew_account_name(v antlr.Token)

func (*Alter_service_master_keyContext) SetNew_password

func (s *Alter_service_master_keyContext) SetNew_password(v antlr.Token)

func (*Alter_service_master_keyContext) SetOld_password

func (s *Alter_service_master_keyContext) SetOld_password(v antlr.Token)

func (*Alter_service_master_keyContext) ToStringTree

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

func (*Alter_service_master_keyContext) WITH

type Alter_symmetric_keyContext

type Alter_symmetric_keyContext struct {
	*antlr.BaseParserRuleContext

	Asym_key_name IIdContext
	// contains filtered or unexported fields
}

func NewAlter_symmetric_keyContext

func NewAlter_symmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_symmetric_keyContext

func NewEmptyAlter_symmetric_keyContext

func NewEmptyAlter_symmetric_keyContext() *Alter_symmetric_keyContext

func (*Alter_symmetric_keyContext) ADD

func (*Alter_symmetric_keyContext) ALTER

func (*Alter_symmetric_keyContext) ASYMMETRIC

func (*Alter_symmetric_keyContext) AllId

func (*Alter_symmetric_keyContext) AllKEY

func (*Alter_symmetric_keyContext) AllSYMMETRIC

func (s *Alter_symmetric_keyContext) AllSYMMETRIC() []antlr.TerminalNode

func (*Alter_symmetric_keyContext) BY

func (*Alter_symmetric_keyContext) CERTIFICATE

func (*Alter_symmetric_keyContext) DROP

func (*Alter_symmetric_keyContext) ENCRYPTION

func (*Alter_symmetric_keyContext) EQUAL

func (*Alter_symmetric_keyContext) EnterRule

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

func (*Alter_symmetric_keyContext) ExitRule

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

func (*Alter_symmetric_keyContext) GetAsym_key_name

func (s *Alter_symmetric_keyContext) GetAsym_key_name() IIdContext

func (*Alter_symmetric_keyContext) GetCertificate_name

func (s *Alter_symmetric_keyContext) GetCertificate_name() IIdContext

func (*Alter_symmetric_keyContext) GetKey_name

func (s *Alter_symmetric_keyContext) GetKey_name() IIdContext

func (*Alter_symmetric_keyContext) GetParser

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

func (*Alter_symmetric_keyContext) GetPassword

func (s *Alter_symmetric_keyContext) GetPassword() antlr.Token

func (*Alter_symmetric_keyContext) GetRuleContext

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

func (*Alter_symmetric_keyContext) GetSymmetric_key_name

func (s *Alter_symmetric_keyContext) GetSymmetric_key_name() IIdContext

func (*Alter_symmetric_keyContext) Id

func (*Alter_symmetric_keyContext) IsAlter_symmetric_keyContext

func (*Alter_symmetric_keyContext) IsAlter_symmetric_keyContext()

func (*Alter_symmetric_keyContext) KEY

func (*Alter_symmetric_keyContext) PASSWORD

func (*Alter_symmetric_keyContext) STRING

func (*Alter_symmetric_keyContext) SYMMETRIC

func (*Alter_symmetric_keyContext) SetAsym_key_name

func (s *Alter_symmetric_keyContext) SetAsym_key_name(v IIdContext)

func (*Alter_symmetric_keyContext) SetCertificate_name

func (s *Alter_symmetric_keyContext) SetCertificate_name(v IIdContext)

func (*Alter_symmetric_keyContext) SetKey_name

func (s *Alter_symmetric_keyContext) SetKey_name(v IIdContext)

func (*Alter_symmetric_keyContext) SetPassword

func (s *Alter_symmetric_keyContext) SetPassword(v antlr.Token)

func (*Alter_symmetric_keyContext) SetSymmetric_key_name

func (s *Alter_symmetric_keyContext) SetSymmetric_key_name(v IIdContext)

func (*Alter_symmetric_keyContext) ToStringTree

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

type Alter_tableContext

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

func NewAlter_tableContext

func NewAlter_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tableContext

func NewEmptyAlter_tableContext

func NewEmptyAlter_tableContext() *Alter_tableContext

func (*Alter_tableContext) ADD

func (*Alter_tableContext) ALTER

func (*Alter_tableContext) AUTO

func (*Alter_tableContext) AllALTER

func (s *Alter_tableContext) AllALTER() []antlr.TerminalNode

func (*Alter_tableContext) AllColumn_name_list

func (s *Alter_tableContext) AllColumn_name_list() []IColumn_name_listContext

func (*Alter_tableContext) AllLR_BRACKET

func (s *Alter_tableContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Alter_tableContext) AllRR_BRACKET

func (s *Alter_tableContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Alter_tableContext) AllTABLE

func (s *Alter_tableContext) AllTABLE() []antlr.TerminalNode

func (*Alter_tableContext) AllTable_name

func (s *Alter_tableContext) AllTable_name() []ITable_nameContext

func (*Alter_tableContext) CHECK

func (*Alter_tableContext) COLUMN

func (*Alter_tableContext) CONSTRAINT

func (s *Alter_tableContext) CONSTRAINT() antlr.TerminalNode

func (*Alter_tableContext) Column_def_table_constraint

func (s *Alter_tableContext) Column_def_table_constraint() IColumn_def_table_constraintContext

func (*Alter_tableContext) Column_definition

func (s *Alter_tableContext) Column_definition() IColumn_definitionContext

func (*Alter_tableContext) Column_name_list

func (s *Alter_tableContext) Column_name_list(i int) IColumn_name_listContext

func (*Alter_tableContext) DISABLE

func (s *Alter_tableContext) DISABLE() antlr.TerminalNode

func (*Alter_tableContext) DROP

func (*Alter_tableContext) ENABLE

func (*Alter_tableContext) EQUAL

func (*Alter_tableContext) EnterRule

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

func (*Alter_tableContext) ExitRule

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

func (*Alter_tableContext) FOREIGN

func (s *Alter_tableContext) FOREIGN() antlr.TerminalNode

func (*Alter_tableContext) GetConstraint

func (s *Alter_tableContext) GetConstraint() IIdContext

func (*Alter_tableContext) GetFk

func (*Alter_tableContext) GetParser

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

func (*Alter_tableContext) GetPk

func (*Alter_tableContext) GetRuleContext

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

func (*Alter_tableContext) Id

func (*Alter_tableContext) IsAlter_tableContext

func (*Alter_tableContext) IsAlter_tableContext()

func (*Alter_tableContext) KEY

func (*Alter_tableContext) LOCK_ESCALATION

func (s *Alter_tableContext) LOCK_ESCALATION() antlr.TerminalNode

func (*Alter_tableContext) LR_BRACKET

func (s *Alter_tableContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Alter_tableContext) REBUILD

func (s *Alter_tableContext) REBUILD() antlr.TerminalNode

func (*Alter_tableContext) REFERENCES

func (s *Alter_tableContext) REFERENCES() antlr.TerminalNode

func (*Alter_tableContext) RR_BRACKET

func (s *Alter_tableContext) RR_BRACKET(i int) antlr.TerminalNode

func (*Alter_tableContext) SEMI

func (*Alter_tableContext) SET

func (*Alter_tableContext) SetConstraint

func (s *Alter_tableContext) SetConstraint(v IIdContext)

func (*Alter_tableContext) SetFk

func (*Alter_tableContext) SetPk

func (*Alter_tableContext) TABLE

func (*Alter_tableContext) TRIGGER

func (s *Alter_tableContext) TRIGGER() antlr.TerminalNode

func (*Alter_tableContext) Table_name

func (s *Alter_tableContext) Table_name(i int) ITable_nameContext

func (*Alter_tableContext) Table_options

func (s *Alter_tableContext) Table_options() ITable_optionsContext

func (*Alter_tableContext) ToStringTree

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

func (*Alter_tableContext) WITH

type Alter_userContext

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

func NewAlter_userContext

func NewAlter_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_userContext

func NewEmptyAlter_userContext

func NewEmptyAlter_userContext() *Alter_userContext

func (*Alter_userContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS

func (s *Alter_userContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS(i int) antlr.TerminalNode

func (*Alter_userContext) ALTER

func (*Alter_userContext) AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS

func (s *Alter_userContext) AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS() []antlr.TerminalNode

func (*Alter_userContext) AllCOMMA

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

func (*Alter_userContext) AllDECIMAL

func (s *Alter_userContext) AllDECIMAL() []antlr.TerminalNode

func (*Alter_userContext) AllDEFAULT_LANGUAGE

func (s *Alter_userContext) AllDEFAULT_LANGUAGE() []antlr.TerminalNode

func (*Alter_userContext) AllDEFAULT_SCHEMA

func (s *Alter_userContext) AllDEFAULT_SCHEMA() []antlr.TerminalNode

func (*Alter_userContext) AllEQUAL

func (s *Alter_userContext) AllEQUAL() []antlr.TerminalNode

func (*Alter_userContext) AllId

func (s *Alter_userContext) AllId() []IIdContext

func (*Alter_userContext) AllLOGIN

func (s *Alter_userContext) AllLOGIN() []antlr.TerminalNode

func (*Alter_userContext) AllNAME

func (s *Alter_userContext) AllNAME() []antlr.TerminalNode

func (*Alter_userContext) AllNONE

func (s *Alter_userContext) AllNONE() []antlr.TerminalNode

func (*Alter_userContext) AllNULL

func (s *Alter_userContext) AllNULL() []antlr.TerminalNode

func (*Alter_userContext) AllOFF

func (s *Alter_userContext) AllOFF() []antlr.TerminalNode

func (*Alter_userContext) AllOLD_PASSWORD

func (s *Alter_userContext) AllOLD_PASSWORD() []antlr.TerminalNode

func (*Alter_userContext) AllON

func (s *Alter_userContext) AllON() []antlr.TerminalNode

func (*Alter_userContext) AllPASSWORD

func (s *Alter_userContext) AllPASSWORD() []antlr.TerminalNode

func (*Alter_userContext) AllSTRING

func (s *Alter_userContext) AllSTRING() []antlr.TerminalNode

func (*Alter_userContext) COMMA

func (*Alter_userContext) DECIMAL

func (s *Alter_userContext) DECIMAL(i int) antlr.TerminalNode

func (*Alter_userContext) DEFAULT_LANGUAGE

func (s *Alter_userContext) DEFAULT_LANGUAGE(i int) antlr.TerminalNode

func (*Alter_userContext) DEFAULT_SCHEMA

func (s *Alter_userContext) DEFAULT_SCHEMA(i int) antlr.TerminalNode

func (*Alter_userContext) EQUAL

func (*Alter_userContext) EnterRule

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

func (*Alter_userContext) ExitRule

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

func (*Alter_userContext) GetLanguage_name_or_alias

func (s *Alter_userContext) GetLanguage_name_or_alias() IIdContext

func (*Alter_userContext) GetLcid

func (s *Alter_userContext) GetLcid() antlr.Token

func (*Alter_userContext) GetLoginame

func (s *Alter_userContext) GetLoginame() IIdContext

func (*Alter_userContext) GetNewusername

func (s *Alter_userContext) GetNewusername() IIdContext

func (*Alter_userContext) GetParser

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

func (*Alter_userContext) GetRuleContext

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

func (*Alter_userContext) GetSchema_name

func (s *Alter_userContext) GetSchema_name() IIdContext

func (*Alter_userContext) GetUsername

func (s *Alter_userContext) GetUsername() IIdContext

func (*Alter_userContext) Id

func (s *Alter_userContext) Id(i int) IIdContext

func (*Alter_userContext) IsAlter_userContext

func (*Alter_userContext) IsAlter_userContext()

func (*Alter_userContext) LOGIN

func (*Alter_userContext) NAME

func (*Alter_userContext) NONE

func (*Alter_userContext) NULL

func (*Alter_userContext) OFF

func (*Alter_userContext) OLD_PASSWORD

func (s *Alter_userContext) OLD_PASSWORD(i int) antlr.TerminalNode

func (*Alter_userContext) ON

func (*Alter_userContext) PASSWORD

func (s *Alter_userContext) PASSWORD(i int) antlr.TerminalNode

func (*Alter_userContext) STRING

func (s *Alter_userContext) STRING(i int) antlr.TerminalNode

func (*Alter_userContext) SetLanguage_name_or_alias

func (s *Alter_userContext) SetLanguage_name_or_alias(v IIdContext)

func (*Alter_userContext) SetLcid

func (s *Alter_userContext) SetLcid(v antlr.Token)

func (*Alter_userContext) SetLoginame

func (s *Alter_userContext) SetLoginame(v IIdContext)

func (*Alter_userContext) SetNewusername

func (s *Alter_userContext) SetNewusername(v IIdContext)

func (*Alter_userContext) SetSchema_name

func (s *Alter_userContext) SetSchema_name(v IIdContext)

func (*Alter_userContext) SetUsername

func (s *Alter_userContext) SetUsername(v IIdContext)

func (*Alter_userContext) ToStringTree

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

func (*Alter_userContext) USER

func (*Alter_userContext) WITH

type Alter_user_azure_sqlContext

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

func NewAlter_user_azure_sqlContext

func NewAlter_user_azure_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_user_azure_sqlContext

func NewEmptyAlter_user_azure_sqlContext

func NewEmptyAlter_user_azure_sqlContext() *Alter_user_azure_sqlContext

func (*Alter_user_azure_sqlContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS

func (s *Alter_user_azure_sqlContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS(i int) antlr.TerminalNode

func (*Alter_user_azure_sqlContext) ALTER

func (*Alter_user_azure_sqlContext) AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS

func (s *Alter_user_azure_sqlContext) AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS() []antlr.TerminalNode

func (*Alter_user_azure_sqlContext) AllCOMMA

func (*Alter_user_azure_sqlContext) AllDEFAULT_SCHEMA

func (s *Alter_user_azure_sqlContext) AllDEFAULT_SCHEMA() []antlr.TerminalNode

func (*Alter_user_azure_sqlContext) AllEQUAL

func (*Alter_user_azure_sqlContext) AllId

func (*Alter_user_azure_sqlContext) AllLOGIN

func (*Alter_user_azure_sqlContext) AllNAME

func (*Alter_user_azure_sqlContext) AllOFF

func (*Alter_user_azure_sqlContext) AllON

func (*Alter_user_azure_sqlContext) COMMA

func (*Alter_user_azure_sqlContext) DEFAULT_SCHEMA

func (s *Alter_user_azure_sqlContext) DEFAULT_SCHEMA(i int) antlr.TerminalNode

func (*Alter_user_azure_sqlContext) EQUAL

func (*Alter_user_azure_sqlContext) EnterRule

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

func (*Alter_user_azure_sqlContext) ExitRule

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

func (*Alter_user_azure_sqlContext) GetLoginame

func (s *Alter_user_azure_sqlContext) GetLoginame() IIdContext

func (*Alter_user_azure_sqlContext) GetNewusername

func (s *Alter_user_azure_sqlContext) GetNewusername() IIdContext

func (*Alter_user_azure_sqlContext) GetParser

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

func (*Alter_user_azure_sqlContext) GetRuleContext

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

func (*Alter_user_azure_sqlContext) GetSchema_name

func (s *Alter_user_azure_sqlContext) GetSchema_name() IIdContext

func (*Alter_user_azure_sqlContext) GetUsername

func (s *Alter_user_azure_sqlContext) GetUsername() IIdContext

func (*Alter_user_azure_sqlContext) Id

func (*Alter_user_azure_sqlContext) IsAlter_user_azure_sqlContext

func (*Alter_user_azure_sqlContext) IsAlter_user_azure_sqlContext()

func (*Alter_user_azure_sqlContext) LOGIN

func (*Alter_user_azure_sqlContext) NAME

func (*Alter_user_azure_sqlContext) OFF

func (*Alter_user_azure_sqlContext) ON

func (*Alter_user_azure_sqlContext) SetLoginame

func (s *Alter_user_azure_sqlContext) SetLoginame(v IIdContext)

func (*Alter_user_azure_sqlContext) SetNewusername

func (s *Alter_user_azure_sqlContext) SetNewusername(v IIdContext)

func (*Alter_user_azure_sqlContext) SetSchema_name

func (s *Alter_user_azure_sqlContext) SetSchema_name(v IIdContext)

func (*Alter_user_azure_sqlContext) SetUsername

func (s *Alter_user_azure_sqlContext) SetUsername(v IIdContext)

func (*Alter_user_azure_sqlContext) ToStringTree

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

func (*Alter_user_azure_sqlContext) USER

func (*Alter_user_azure_sqlContext) WITH

type Alter_workload_groupContext

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

func NewAlter_workload_groupContext

func NewAlter_workload_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_workload_groupContext

func NewEmptyAlter_workload_groupContext

func NewEmptyAlter_workload_groupContext() *Alter_workload_groupContext

func (*Alter_workload_groupContext) ALTER

func (*Alter_workload_groupContext) AllCOMMA

func (*Alter_workload_groupContext) AllDECIMAL

func (*Alter_workload_groupContext) AllDEFAULT_DOUBLE_QUOTE

func (s *Alter_workload_groupContext) AllDEFAULT_DOUBLE_QUOTE() []antlr.TerminalNode

func (*Alter_workload_groupContext) AllEQUAL

func (*Alter_workload_groupContext) AllGROUP_MAX_REQUESTS

func (s *Alter_workload_groupContext) AllGROUP_MAX_REQUESTS() []antlr.TerminalNode

func (*Alter_workload_groupContext) AllHIGH

func (*Alter_workload_groupContext) AllIMPORTANCE

func (s *Alter_workload_groupContext) AllIMPORTANCE() []antlr.TerminalNode

func (*Alter_workload_groupContext) AllId

func (*Alter_workload_groupContext) AllLOW

func (*Alter_workload_groupContext) AllMAX_DOP

func (*Alter_workload_groupContext) AllMEDIUM

func (*Alter_workload_groupContext) AllREQUEST_MAX_CPU_TIME_SEC

func (s *Alter_workload_groupContext) AllREQUEST_MAX_CPU_TIME_SEC() []antlr.TerminalNode

func (*Alter_workload_groupContext) AllREQUEST_MAX_MEMORY_GRANT_PERCENT

func (s *Alter_workload_groupContext) AllREQUEST_MAX_MEMORY_GRANT_PERCENT() []antlr.TerminalNode

func (*Alter_workload_groupContext) AllREQUEST_MEMORY_GRANT_TIMEOUT_SEC

func (s *Alter_workload_groupContext) AllREQUEST_MEMORY_GRANT_TIMEOUT_SEC() []antlr.TerminalNode

func (*Alter_workload_groupContext) COMMA

func (*Alter_workload_groupContext) DECIMAL

func (*Alter_workload_groupContext) DEFAULT_DOUBLE_QUOTE

func (s *Alter_workload_groupContext) DEFAULT_DOUBLE_QUOTE(i int) antlr.TerminalNode

func (*Alter_workload_groupContext) EQUAL

func (*Alter_workload_groupContext) EnterRule

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

func (*Alter_workload_groupContext) ExitRule

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

func (*Alter_workload_groupContext) GROUP

func (*Alter_workload_groupContext) GROUP_MAX_REQUESTS

func (s *Alter_workload_groupContext) GROUP_MAX_REQUESTS(i int) antlr.TerminalNode

func (*Alter_workload_groupContext) GetGroup_max_requests

func (s *Alter_workload_groupContext) GetGroup_max_requests() antlr.Token

func (*Alter_workload_groupContext) GetMax_dop

func (s *Alter_workload_groupContext) GetMax_dop() antlr.Token

func (*Alter_workload_groupContext) GetParser

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

func (*Alter_workload_groupContext) GetRequest_max_cpu_time_sec

func (s *Alter_workload_groupContext) GetRequest_max_cpu_time_sec() antlr.Token

func (*Alter_workload_groupContext) GetRequest_max_memory_grant

func (s *Alter_workload_groupContext) GetRequest_max_memory_grant() antlr.Token

func (*Alter_workload_groupContext) GetRequest_memory_grant_timeout_sec

func (s *Alter_workload_groupContext) GetRequest_memory_grant_timeout_sec() antlr.Token

func (*Alter_workload_groupContext) GetRuleContext

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

func (*Alter_workload_groupContext) GetWorkload_group_group_name

func (s *Alter_workload_groupContext) GetWorkload_group_group_name() IIdContext

func (*Alter_workload_groupContext) GetWorkload_group_pool_name

func (s *Alter_workload_groupContext) GetWorkload_group_pool_name() IIdContext

func (*Alter_workload_groupContext) HIGH

func (*Alter_workload_groupContext) IMPORTANCE

func (*Alter_workload_groupContext) Id

func (*Alter_workload_groupContext) IsAlter_workload_groupContext

func (*Alter_workload_groupContext) IsAlter_workload_groupContext()

func (*Alter_workload_groupContext) LOW

func (*Alter_workload_groupContext) LR_BRACKET

func (*Alter_workload_groupContext) MAX_DOP

func (*Alter_workload_groupContext) MEDIUM

func (*Alter_workload_groupContext) REQUEST_MAX_CPU_TIME_SEC

func (s *Alter_workload_groupContext) REQUEST_MAX_CPU_TIME_SEC(i int) antlr.TerminalNode

func (*Alter_workload_groupContext) REQUEST_MAX_MEMORY_GRANT_PERCENT

func (s *Alter_workload_groupContext) REQUEST_MAX_MEMORY_GRANT_PERCENT(i int) antlr.TerminalNode

func (*Alter_workload_groupContext) REQUEST_MEMORY_GRANT_TIMEOUT_SEC

func (s *Alter_workload_groupContext) REQUEST_MEMORY_GRANT_TIMEOUT_SEC(i int) antlr.TerminalNode

func (*Alter_workload_groupContext) RR_BRACKET

func (*Alter_workload_groupContext) SetGroup_max_requests

func (s *Alter_workload_groupContext) SetGroup_max_requests(v antlr.Token)

func (*Alter_workload_groupContext) SetMax_dop

func (s *Alter_workload_groupContext) SetMax_dop(v antlr.Token)

func (*Alter_workload_groupContext) SetRequest_max_cpu_time_sec

func (s *Alter_workload_groupContext) SetRequest_max_cpu_time_sec(v antlr.Token)

func (*Alter_workload_groupContext) SetRequest_max_memory_grant

func (s *Alter_workload_groupContext) SetRequest_max_memory_grant(v antlr.Token)

func (*Alter_workload_groupContext) SetRequest_memory_grant_timeout_sec

func (s *Alter_workload_groupContext) SetRequest_memory_grant_timeout_sec(v antlr.Token)

func (*Alter_workload_groupContext) SetWorkload_group_group_name

func (s *Alter_workload_groupContext) SetWorkload_group_group_name(v IIdContext)

func (*Alter_workload_groupContext) SetWorkload_group_pool_name

func (s *Alter_workload_groupContext) SetWorkload_group_pool_name(v IIdContext)

func (*Alter_workload_groupContext) ToStringTree

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

func (*Alter_workload_groupContext) USING

func (*Alter_workload_groupContext) WITH

func (*Alter_workload_groupContext) WORKLOAD

type Analytic_windowed_functionContext

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

func NewAnalytic_windowed_functionContext

func NewAnalytic_windowed_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Analytic_windowed_functionContext

func NewEmptyAnalytic_windowed_functionContext

func NewEmptyAnalytic_windowed_functionContext() *Analytic_windowed_functionContext

func (*Analytic_windowed_functionContext) AllCOMMA

func (*Analytic_windowed_functionContext) AllExpression

func (*Analytic_windowed_functionContext) COMMA

func (*Analytic_windowed_functionContext) EnterRule

func (*Analytic_windowed_functionContext) ExitRule

func (*Analytic_windowed_functionContext) Expression

func (*Analytic_windowed_functionContext) FIRST_VALUE

func (*Analytic_windowed_functionContext) GetParser

func (*Analytic_windowed_functionContext) GetRuleContext

func (*Analytic_windowed_functionContext) IsAnalytic_windowed_functionContext

func (*Analytic_windowed_functionContext) IsAnalytic_windowed_functionContext()

func (*Analytic_windowed_functionContext) LAG

func (*Analytic_windowed_functionContext) LAST_VALUE

func (*Analytic_windowed_functionContext) LEAD

func (*Analytic_windowed_functionContext) LR_BRACKET

func (*Analytic_windowed_functionContext) Over_clause

func (*Analytic_windowed_functionContext) RR_BRACKET

func (*Analytic_windowed_functionContext) ToStringTree

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

type Another_statementContext

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

func NewAnother_statementContext

func NewAnother_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Another_statementContext

func NewEmptyAnother_statementContext

func NewEmptyAnother_statementContext() *Another_statementContext

func (*Another_statementContext) Alter_queue

func (*Another_statementContext) Conversation_statement

func (s *Another_statementContext) Conversation_statement() IConversation_statementContext

func (*Another_statementContext) Create_contract

func (*Another_statementContext) Create_queue

func (*Another_statementContext) Cursor_statement

func (s *Another_statementContext) Cursor_statement() ICursor_statementContext

func (*Another_statementContext) Declare_statement

func (s *Another_statementContext) Declare_statement() IDeclare_statementContext

func (*Another_statementContext) EnterRule

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

func (*Another_statementContext) Execute_statement

func (s *Another_statementContext) Execute_statement() IExecute_statementContext

func (*Another_statementContext) ExitRule

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

func (*Another_statementContext) GetParser

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

func (*Another_statementContext) GetRuleContext

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

func (*Another_statementContext) IsAnother_statementContext

func (*Another_statementContext) IsAnother_statementContext()

func (*Another_statementContext) Message_statement

func (s *Another_statementContext) Message_statement() IMessage_statementContext

func (*Another_statementContext) Security_statement

func (s *Another_statementContext) Security_statement() ISecurity_statementContext

func (*Another_statementContext) Set_statement

func (*Another_statementContext) Setuser_statement

func (s *Another_statementContext) Setuser_statement() ISetuser_statementContext

func (*Another_statementContext) ToStringTree

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

func (*Another_statementContext) Transaction_statement

func (s *Another_statementContext) Transaction_statement() ITransaction_statementContext

func (*Another_statementContext) Use_statement

type As_column_aliasContext

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

func NewAs_column_aliasContext

func NewAs_column_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *As_column_aliasContext

func NewEmptyAs_column_aliasContext

func NewEmptyAs_column_aliasContext() *As_column_aliasContext

func (*As_column_aliasContext) AS

func (*As_column_aliasContext) Column_alias

func (s *As_column_aliasContext) Column_alias() IColumn_aliasContext

func (*As_column_aliasContext) EnterRule

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

func (*As_column_aliasContext) ExitRule

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

func (*As_column_aliasContext) GetParser

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

func (*As_column_aliasContext) GetRuleContext

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

func (*As_column_aliasContext) IsAs_column_aliasContext

func (*As_column_aliasContext) IsAs_column_aliasContext()

func (*As_column_aliasContext) ToStringTree

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

type As_table_aliasContext

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

func NewAs_table_aliasContext

func NewAs_table_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *As_table_aliasContext

func NewEmptyAs_table_aliasContext

func NewEmptyAs_table_aliasContext() *As_table_aliasContext

func (*As_table_aliasContext) AS

func (*As_table_aliasContext) EnterRule

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

func (*As_table_aliasContext) ExitRule

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

func (*As_table_aliasContext) GetParser

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

func (*As_table_aliasContext) GetRuleContext

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

func (*As_table_aliasContext) IsAs_table_aliasContext

func (*As_table_aliasContext) IsAs_table_aliasContext()

func (*As_table_aliasContext) Table_alias

func (s *As_table_aliasContext) Table_alias() ITable_aliasContext

func (*As_table_aliasContext) ToStringTree

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

type Assembly_optionContext

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

func NewAssembly_optionContext

func NewAssembly_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assembly_optionContext

func NewEmptyAssembly_optionContext

func NewEmptyAssembly_optionContext() *Assembly_optionContext

func (*Assembly_optionContext) Assembly_option

func (s *Assembly_optionContext) Assembly_option() IAssembly_optionContext

func (*Assembly_optionContext) COMMA

func (*Assembly_optionContext) DATA

func (*Assembly_optionContext) EQUAL

func (*Assembly_optionContext) EXTERNAL_ACCESS

func (s *Assembly_optionContext) EXTERNAL_ACCESS() antlr.TerminalNode

func (*Assembly_optionContext) EnterRule

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

func (*Assembly_optionContext) ExitRule

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

func (*Assembly_optionContext) GetParser

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

func (*Assembly_optionContext) GetRuleContext

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

func (*Assembly_optionContext) IsAssembly_optionContext

func (*Assembly_optionContext) IsAssembly_optionContext()

func (*Assembly_optionContext) OFF

func (*Assembly_optionContext) ON

func (*Assembly_optionContext) PERMISSION_SET

func (s *Assembly_optionContext) PERMISSION_SET() antlr.TerminalNode

func (*Assembly_optionContext) SAFE

func (*Assembly_optionContext) ToStringTree

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

func (*Assembly_optionContext) UNCHECKED

func (s *Assembly_optionContext) UNCHECKED() antlr.TerminalNode

func (*Assembly_optionContext) UNSAFE

func (*Assembly_optionContext) VISIBILITY

func (s *Assembly_optionContext) VISIBILITY() antlr.TerminalNode

type Assignment_operatorContext

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

func NewAssignment_operatorContext

func NewAssignment_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assignment_operatorContext

func NewEmptyAssignment_operatorContext

func NewEmptyAssignment_operatorContext() *Assignment_operatorContext

func (*Assignment_operatorContext) AND_ASSIGN

func (*Assignment_operatorContext) DIV_ASSIGN

func (*Assignment_operatorContext) EnterRule

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

func (*Assignment_operatorContext) ExitRule

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

func (*Assignment_operatorContext) GetParser

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

func (*Assignment_operatorContext) GetRuleContext

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

func (*Assignment_operatorContext) IsAssignment_operatorContext

func (*Assignment_operatorContext) IsAssignment_operatorContext()

func (*Assignment_operatorContext) MINUS_ASSIGN

func (s *Assignment_operatorContext) MINUS_ASSIGN() antlr.TerminalNode

func (*Assignment_operatorContext) MOD_ASSIGN

func (*Assignment_operatorContext) MULT_ASSIGN

func (*Assignment_operatorContext) OR_ASSIGN

func (*Assignment_operatorContext) PLUS_ASSIGN

func (*Assignment_operatorContext) ToStringTree

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

func (*Assignment_operatorContext) XOR_ASSIGN

type AsteriskContext

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

func NewAsteriskContext

func NewAsteriskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AsteriskContext

func NewEmptyAsteriskContext

func NewEmptyAsteriskContext() *AsteriskContext

func (*AsteriskContext) Asterisk

func (s *AsteriskContext) Asterisk() IAsteriskContext

func (*AsteriskContext) DOT

func (*AsteriskContext) EnterRule

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

func (*AsteriskContext) ExitRule

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

func (*AsteriskContext) GetParser

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

func (*AsteriskContext) GetRuleContext

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

func (*AsteriskContext) IsAsteriskContext

func (*AsteriskContext) IsAsteriskContext()

func (*AsteriskContext) STAR

func (*AsteriskContext) Table_name

func (s *AsteriskContext) Table_name() ITable_nameContext

func (*AsteriskContext) ToStringTree

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

type Asymmetric_key_optionContext

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

func NewAsymmetric_key_optionContext

func NewAsymmetric_key_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Asymmetric_key_optionContext

func NewEmptyAsymmetric_key_optionContext

func NewEmptyAsymmetric_key_optionContext() *Asymmetric_key_optionContext

func (*Asymmetric_key_optionContext) AllAsymmetric_key_password_change_option

func (s *Asymmetric_key_optionContext) AllAsymmetric_key_password_change_option() []IAsymmetric_key_password_change_optionContext

func (*Asymmetric_key_optionContext) Asymmetric_key_option_start

func (s *Asymmetric_key_optionContext) Asymmetric_key_option_start() IAsymmetric_key_option_startContext

func (*Asymmetric_key_optionContext) Asymmetric_key_password_change_option

func (s *Asymmetric_key_optionContext) Asymmetric_key_password_change_option(i int) IAsymmetric_key_password_change_optionContext

func (*Asymmetric_key_optionContext) COMMA

func (*Asymmetric_key_optionContext) EnterRule

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

func (*Asymmetric_key_optionContext) ExitRule

func (*Asymmetric_key_optionContext) GetParser

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

func (*Asymmetric_key_optionContext) GetRuleContext

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

func (*Asymmetric_key_optionContext) IsAsymmetric_key_optionContext

func (*Asymmetric_key_optionContext) IsAsymmetric_key_optionContext()

func (*Asymmetric_key_optionContext) RR_BRACKET

func (*Asymmetric_key_optionContext) ToStringTree

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

type Asymmetric_key_option_startContext

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

func NewAsymmetric_key_option_startContext

func NewAsymmetric_key_option_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Asymmetric_key_option_startContext

func NewEmptyAsymmetric_key_option_startContext

func NewEmptyAsymmetric_key_option_startContext() *Asymmetric_key_option_startContext

func (*Asymmetric_key_option_startContext) EnterRule

func (*Asymmetric_key_option_startContext) ExitRule

func (*Asymmetric_key_option_startContext) GetParser

func (*Asymmetric_key_option_startContext) GetRuleContext

func (*Asymmetric_key_option_startContext) IsAsymmetric_key_option_startContext

func (*Asymmetric_key_option_startContext) IsAsymmetric_key_option_startContext()

func (*Asymmetric_key_option_startContext) KEY

func (*Asymmetric_key_option_startContext) LR_BRACKET

func (*Asymmetric_key_option_startContext) PRIVATE

func (*Asymmetric_key_option_startContext) ToStringTree

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

func (*Asymmetric_key_option_startContext) WITH

type Asymmetric_key_password_change_optionContext

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

func NewAsymmetric_key_password_change_optionContext

func NewAsymmetric_key_password_change_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Asymmetric_key_password_change_optionContext

func NewEmptyAsymmetric_key_password_change_optionContext

func NewEmptyAsymmetric_key_password_change_optionContext() *Asymmetric_key_password_change_optionContext

func (*Asymmetric_key_password_change_optionContext) BY

func (*Asymmetric_key_password_change_optionContext) DECRYPTION

func (*Asymmetric_key_password_change_optionContext) ENCRYPTION

func (*Asymmetric_key_password_change_optionContext) EQUAL

func (*Asymmetric_key_password_change_optionContext) EnterRule

func (*Asymmetric_key_password_change_optionContext) ExitRule

func (*Asymmetric_key_password_change_optionContext) GetParser

func (*Asymmetric_key_password_change_optionContext) GetRuleContext

func (*Asymmetric_key_password_change_optionContext) IsAsymmetric_key_password_change_optionContext

func (*Asymmetric_key_password_change_optionContext) IsAsymmetric_key_password_change_optionContext()

func (*Asymmetric_key_password_change_optionContext) PASSWORD

func (*Asymmetric_key_password_change_optionContext) STRING

func (*Asymmetric_key_password_change_optionContext) ToStringTree

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

type Authorization_granteeContext

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

func NewAuthorization_granteeContext

func NewAuthorization_granteeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Authorization_granteeContext

func NewEmptyAuthorization_granteeContext

func NewEmptyAuthorization_granteeContext() *Authorization_granteeContext

func (*Authorization_granteeContext) EnterRule

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

func (*Authorization_granteeContext) ExitRule

func (*Authorization_granteeContext) GetParser

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

func (*Authorization_granteeContext) GetPrincipal_name

func (s *Authorization_granteeContext) GetPrincipal_name() IIdContext

func (*Authorization_granteeContext) GetRuleContext

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

func (*Authorization_granteeContext) Id

func (*Authorization_granteeContext) IsAuthorization_granteeContext

func (*Authorization_granteeContext) IsAuthorization_granteeContext()

func (*Authorization_granteeContext) OWNER

func (*Authorization_granteeContext) SCHEMA

func (*Authorization_granteeContext) SetPrincipal_name

func (s *Authorization_granteeContext) SetPrincipal_name(v IIdContext)

func (*Authorization_granteeContext) ToStringTree

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

type Auto_optionContext

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

func NewAuto_optionContext

func NewAuto_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Auto_optionContext

func NewEmptyAuto_optionContext

func NewEmptyAuto_optionContext() *Auto_optionContext

func (*Auto_optionContext) AUTO_CLOSE

func (s *Auto_optionContext) AUTO_CLOSE() antlr.TerminalNode

func (*Auto_optionContext) AUTO_CREATE_STATISTICS

func (s *Auto_optionContext) AUTO_CREATE_STATISTICS() antlr.TerminalNode

func (*Auto_optionContext) AUTO_SHRINK

func (s *Auto_optionContext) AUTO_SHRINK() antlr.TerminalNode

func (*Auto_optionContext) AUTO_UPDATE_STATISTICS

func (s *Auto_optionContext) AUTO_UPDATE_STATISTICS() antlr.TerminalNode

func (*Auto_optionContext) AUTO_UPDATE_STATISTICS_ASYNC

func (s *Auto_optionContext) AUTO_UPDATE_STATISTICS_ASYNC() antlr.TerminalNode

func (*Auto_optionContext) AllON

func (s *Auto_optionContext) AllON() []antlr.TerminalNode

func (*Auto_optionContext) EQUAL

func (*Auto_optionContext) EnterRule

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

func (*Auto_optionContext) ExitRule

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

func (*Auto_optionContext) GetParser

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

func (*Auto_optionContext) GetRuleContext

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

func (*Auto_optionContext) INCREMENTAL

func (s *Auto_optionContext) INCREMENTAL() antlr.TerminalNode

func (*Auto_optionContext) IsAuto_optionContext

func (*Auto_optionContext) IsAuto_optionContext()

func (*Auto_optionContext) OFF

func (*Auto_optionContext) ON

func (*Auto_optionContext) On_off

func (s *Auto_optionContext) On_off() IOn_offContext

func (*Auto_optionContext) ToStringTree

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

type BINARY_CHECKSUMContext

type BINARY_CHECKSUMContext struct {
	*Function_callContext
}

func NewBINARY_CHECKSUMContext

func NewBINARY_CHECKSUMContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *BINARY_CHECKSUMContext

func (*BINARY_CHECKSUMContext) BINARY_CHECKSUM

func (s *BINARY_CHECKSUMContext) BINARY_CHECKSUM() antlr.TerminalNode

func (*BINARY_CHECKSUMContext) EnterRule

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

func (*BINARY_CHECKSUMContext) ExitRule

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

func (*BINARY_CHECKSUMContext) GetRuleContext

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

func (*BINARY_CHECKSUMContext) LR_BRACKET

func (s *BINARY_CHECKSUMContext) LR_BRACKET() antlr.TerminalNode

func (*BINARY_CHECKSUMContext) RR_BRACKET

func (s *BINARY_CHECKSUMContext) RR_BRACKET() antlr.TerminalNode

func (*BINARY_CHECKSUMContext) STAR

type Backup_certificateContext

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

func NewBackup_certificateContext

func NewBackup_certificateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_certificateContext

func NewEmptyBackup_certificateContext

func NewEmptyBackup_certificateContext() *Backup_certificateContext

func (*Backup_certificateContext) AllBY

func (*Backup_certificateContext) AllCOMMA

func (*Backup_certificateContext) AllDECRYPTION

func (s *Backup_certificateContext) AllDECRYPTION() []antlr.TerminalNode

func (*Backup_certificateContext) AllENCRYPTION

func (s *Backup_certificateContext) AllENCRYPTION() []antlr.TerminalNode

func (*Backup_certificateContext) AllEQUAL

func (*Backup_certificateContext) AllFILE

func (*Backup_certificateContext) AllPASSWORD

func (s *Backup_certificateContext) AllPASSWORD() []antlr.TerminalNode

func (*Backup_certificateContext) AllSTRING

func (s *Backup_certificateContext) AllSTRING() []antlr.TerminalNode

func (*Backup_certificateContext) BACKUP

func (*Backup_certificateContext) BY

func (*Backup_certificateContext) CERTIFICATE

func (s *Backup_certificateContext) CERTIFICATE() antlr.TerminalNode

func (*Backup_certificateContext) COMMA

func (*Backup_certificateContext) DECRYPTION

func (*Backup_certificateContext) ENCRYPTION

func (*Backup_certificateContext) EQUAL

func (*Backup_certificateContext) EnterRule

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

func (*Backup_certificateContext) ExitRule

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

func (*Backup_certificateContext) FILE

func (*Backup_certificateContext) GetCert_file

func (s *Backup_certificateContext) GetCert_file() antlr.Token

func (*Backup_certificateContext) GetCertname

func (s *Backup_certificateContext) GetCertname() IIdContext

func (*Backup_certificateContext) GetDecryption_pasword

func (s *Backup_certificateContext) GetDecryption_pasword() antlr.Token

func (*Backup_certificateContext) GetEncryption_password

func (s *Backup_certificateContext) GetEncryption_password() antlr.Token

func (*Backup_certificateContext) GetParser

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

func (*Backup_certificateContext) GetPrivate_key_file

func (s *Backup_certificateContext) GetPrivate_key_file() antlr.Token

func (*Backup_certificateContext) GetRuleContext

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

func (*Backup_certificateContext) Id

func (*Backup_certificateContext) IsBackup_certificateContext

func (*Backup_certificateContext) IsBackup_certificateContext()

func (*Backup_certificateContext) KEY

func (*Backup_certificateContext) LR_BRACKET

func (*Backup_certificateContext) PASSWORD

func (*Backup_certificateContext) PRIVATE

func (*Backup_certificateContext) RR_BRACKET

func (*Backup_certificateContext) STRING

func (*Backup_certificateContext) SetCert_file

func (s *Backup_certificateContext) SetCert_file(v antlr.Token)

func (*Backup_certificateContext) SetCertname

func (s *Backup_certificateContext) SetCertname(v IIdContext)

func (*Backup_certificateContext) SetDecryption_pasword

func (s *Backup_certificateContext) SetDecryption_pasword(v antlr.Token)

func (*Backup_certificateContext) SetEncryption_password

func (s *Backup_certificateContext) SetEncryption_password(v antlr.Token)

func (*Backup_certificateContext) SetPrivate_key_file

func (s *Backup_certificateContext) SetPrivate_key_file(v antlr.Token)

func (*Backup_certificateContext) TO

func (*Backup_certificateContext) ToStringTree

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

func (*Backup_certificateContext) WITH

type Backup_databaseContext

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

func NewBackup_databaseContext

func NewBackup_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_databaseContext

func NewEmptyBackup_databaseContext

func NewEmptyBackup_databaseContext() *Backup_databaseContext

func (*Backup_databaseContext) AES_128

func (*Backup_databaseContext) AES_192

func (*Backup_databaseContext) AES_256

func (*Backup_databaseContext) ALGORITHM

func (s *Backup_databaseContext) ALGORITHM(i int) antlr.TerminalNode

func (*Backup_databaseContext) ASYMMETRIC

func (s *Backup_databaseContext) ASYMMETRIC(i int) antlr.TerminalNode

func (*Backup_databaseContext) AllAES_128

func (s *Backup_databaseContext) AllAES_128() []antlr.TerminalNode

func (*Backup_databaseContext) AllAES_192

func (s *Backup_databaseContext) AllAES_192() []antlr.TerminalNode

func (*Backup_databaseContext) AllAES_256

func (s *Backup_databaseContext) AllAES_256() []antlr.TerminalNode

func (*Backup_databaseContext) AllALGORITHM

func (s *Backup_databaseContext) AllALGORITHM() []antlr.TerminalNode

func (*Backup_databaseContext) AllASYMMETRIC

func (s *Backup_databaseContext) AllASYMMETRIC() []antlr.TerminalNode

func (*Backup_databaseContext) AllBLOCKSIZE

func (s *Backup_databaseContext) AllBLOCKSIZE() []antlr.TerminalNode

func (*Backup_databaseContext) AllBUFFERCOUNT

func (s *Backup_databaseContext) AllBUFFERCOUNT() []antlr.TerminalNode

func (*Backup_databaseContext) AllCERTIFICATE

func (s *Backup_databaseContext) AllCERTIFICATE() []antlr.TerminalNode

func (*Backup_databaseContext) AllCHECKSUM

func (s *Backup_databaseContext) AllCHECKSUM() []antlr.TerminalNode

func (*Backup_databaseContext) AllCOMMA

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

func (*Backup_databaseContext) AllCOMPRESSION

func (s *Backup_databaseContext) AllCOMPRESSION() []antlr.TerminalNode

func (*Backup_databaseContext) AllCONTINUE_AFTER_ERROR

func (s *Backup_databaseContext) AllCONTINUE_AFTER_ERROR() []antlr.TerminalNode

func (*Backup_databaseContext) AllCOPY_ONLY

func (s *Backup_databaseContext) AllCOPY_ONLY() []antlr.TerminalNode

func (*Backup_databaseContext) AllCREDENTIAL

func (s *Backup_databaseContext) AllCREDENTIAL() []antlr.TerminalNode

func (*Backup_databaseContext) AllDECIMAL

func (s *Backup_databaseContext) AllDECIMAL() []antlr.TerminalNode

func (*Backup_databaseContext) AllDESCRIPTION

func (s *Backup_databaseContext) AllDESCRIPTION() []antlr.TerminalNode

func (*Backup_databaseContext) AllDIFFERENTIAL

func (s *Backup_databaseContext) AllDIFFERENTIAL() []antlr.TerminalNode

func (*Backup_databaseContext) AllDISK

func (s *Backup_databaseContext) AllDISK() []antlr.TerminalNode

func (*Backup_databaseContext) AllENCRYPTION

func (s *Backup_databaseContext) AllENCRYPTION() []antlr.TerminalNode

func (*Backup_databaseContext) AllEQUAL

func (s *Backup_databaseContext) AllEQUAL() []antlr.TerminalNode

func (*Backup_databaseContext) AllEXPIREDATE

func (s *Backup_databaseContext) AllEXPIREDATE() []antlr.TerminalNode

func (*Backup_databaseContext) AllFILE

func (s *Backup_databaseContext) AllFILE() []antlr.TerminalNode

func (*Backup_databaseContext) AllFILEGROUP

func (s *Backup_databaseContext) AllFILEGROUP() []antlr.TerminalNode

func (*Backup_databaseContext) AllFILE_SNAPSHOT

func (s *Backup_databaseContext) AllFILE_SNAPSHOT() []antlr.TerminalNode

func (*Backup_databaseContext) AllFORMAT

func (s *Backup_databaseContext) AllFORMAT() []antlr.TerminalNode

func (*Backup_databaseContext) AllINIT

func (s *Backup_databaseContext) AllINIT() []antlr.TerminalNode

func (*Backup_databaseContext) AllId

func (s *Backup_databaseContext) AllId() []IIdContext

func (*Backup_databaseContext) AllKEY

func (*Backup_databaseContext) AllLOAD

func (s *Backup_databaseContext) AllLOAD() []antlr.TerminalNode

func (*Backup_databaseContext) AllLR_BRACKET

func (s *Backup_databaseContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Backup_databaseContext) AllMAXTRANSFER

func (s *Backup_databaseContext) AllMAXTRANSFER() []antlr.TerminalNode

func (*Backup_databaseContext) AllMEDIADESCRIPTION

func (s *Backup_databaseContext) AllMEDIADESCRIPTION() []antlr.TerminalNode

func (*Backup_databaseContext) AllMEDIANAME

func (s *Backup_databaseContext) AllMEDIANAME() []antlr.TerminalNode

func (*Backup_databaseContext) AllMIRROR

func (s *Backup_databaseContext) AllMIRROR() []antlr.TerminalNode

func (*Backup_databaseContext) AllNAME

func (s *Backup_databaseContext) AllNAME() []antlr.TerminalNode

func (*Backup_databaseContext) AllNOFORMAT

func (s *Backup_databaseContext) AllNOFORMAT() []antlr.TerminalNode

func (*Backup_databaseContext) AllNOINIT

func (s *Backup_databaseContext) AllNOINIT() []antlr.TerminalNode

func (*Backup_databaseContext) AllNOREWIND

func (s *Backup_databaseContext) AllNOREWIND() []antlr.TerminalNode

func (*Backup_databaseContext) AllNOSKIP

func (s *Backup_databaseContext) AllNOSKIP() []antlr.TerminalNode

func (*Backup_databaseContext) AllNOUNLOAD

func (s *Backup_databaseContext) AllNOUNLOAD() []antlr.TerminalNode

func (*Backup_databaseContext) AllNO_CHECKSUM

func (s *Backup_databaseContext) AllNO_CHECKSUM() []antlr.TerminalNode

func (*Backup_databaseContext) AllNO_COMPRESSION

func (s *Backup_databaseContext) AllNO_COMPRESSION() []antlr.TerminalNode

func (*Backup_databaseContext) AllRESTART

func (s *Backup_databaseContext) AllRESTART() []antlr.TerminalNode

func (*Backup_databaseContext) AllRETAINDAYS

func (s *Backup_databaseContext) AllRETAINDAYS() []antlr.TerminalNode

func (*Backup_databaseContext) AllREWIND

func (s *Backup_databaseContext) AllREWIND() []antlr.TerminalNode

func (*Backup_databaseContext) AllSERVER

func (s *Backup_databaseContext) AllSERVER() []antlr.TerminalNode

func (*Backup_databaseContext) AllSKIP_KEYWORD

func (s *Backup_databaseContext) AllSKIP_KEYWORD() []antlr.TerminalNode

func (*Backup_databaseContext) AllSTATS

func (s *Backup_databaseContext) AllSTATS() []antlr.TerminalNode

func (*Backup_databaseContext) AllSTOP_ON_ERROR

func (s *Backup_databaseContext) AllSTOP_ON_ERROR() []antlr.TerminalNode

func (*Backup_databaseContext) AllSTRING

func (s *Backup_databaseContext) AllSTRING() []antlr.TerminalNode

func (*Backup_databaseContext) AllTAPE

func (s *Backup_databaseContext) AllTAPE() []antlr.TerminalNode

func (*Backup_databaseContext) AllTO

func (*Backup_databaseContext) AllTRIPLE_DES_3KEY

func (s *Backup_databaseContext) AllTRIPLE_DES_3KEY() []antlr.TerminalNode

func (*Backup_databaseContext) AllURL

func (*Backup_databaseContext) BACKUP

func (*Backup_databaseContext) BLOCKSIZE

func (s *Backup_databaseContext) BLOCKSIZE(i int) antlr.TerminalNode

func (*Backup_databaseContext) BUFFERCOUNT

func (s *Backup_databaseContext) BUFFERCOUNT(i int) antlr.TerminalNode

func (*Backup_databaseContext) CERTIFICATE

func (s *Backup_databaseContext) CERTIFICATE(i int) antlr.TerminalNode

func (*Backup_databaseContext) CHECKSUM

func (*Backup_databaseContext) COMMA

func (*Backup_databaseContext) COMPRESSION

func (s *Backup_databaseContext) COMPRESSION(i int) antlr.TerminalNode

func (*Backup_databaseContext) CONTINUE_AFTER_ERROR

func (s *Backup_databaseContext) CONTINUE_AFTER_ERROR(i int) antlr.TerminalNode

func (*Backup_databaseContext) COPY_ONLY

func (s *Backup_databaseContext) COPY_ONLY(i int) antlr.TerminalNode

func (*Backup_databaseContext) CREDENTIAL

func (s *Backup_databaseContext) CREDENTIAL(i int) antlr.TerminalNode

func (*Backup_databaseContext) DATABASE

func (*Backup_databaseContext) DECIMAL

func (*Backup_databaseContext) DESCRIPTION

func (s *Backup_databaseContext) DESCRIPTION(i int) antlr.TerminalNode

func (*Backup_databaseContext) DIFFERENTIAL

func (s *Backup_databaseContext) DIFFERENTIAL(i int) antlr.TerminalNode

func (*Backup_databaseContext) DISK

func (*Backup_databaseContext) ENCRYPTION

func (s *Backup_databaseContext) ENCRYPTION(i int) antlr.TerminalNode

func (*Backup_databaseContext) EQUAL

func (*Backup_databaseContext) EXPIREDATE

func (s *Backup_databaseContext) EXPIREDATE(i int) antlr.TerminalNode

func (*Backup_databaseContext) EnterRule

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

func (*Backup_databaseContext) ExitRule

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

func (*Backup_databaseContext) FILE

func (*Backup_databaseContext) FILEGROUP

func (s *Backup_databaseContext) FILEGROUP(i int) antlr.TerminalNode

func (*Backup_databaseContext) FILE_SNAPSHOT

func (s *Backup_databaseContext) FILE_SNAPSHOT(i int) antlr.TerminalNode

func (*Backup_databaseContext) FORMAT

func (*Backup_databaseContext) GetBackup_set_name

func (s *Backup_databaseContext) GetBackup_set_name() IIdContext

func (*Backup_databaseContext) GetDatabase_name

func (s *Backup_databaseContext) GetDatabase_name() IIdContext

func (*Backup_databaseContext) GetEncryptor_name

func (s *Backup_databaseContext) GetEncryptor_name() IIdContext

func (*Backup_databaseContext) GetFile_or_filegroup

func (s *Backup_databaseContext) GetFile_or_filegroup() antlr.Token

func (*Backup_databaseContext) GetLogical_device_name

func (s *Backup_databaseContext) GetLogical_device_name() IIdContext

func (*Backup_databaseContext) GetMedianame

func (s *Backup_databaseContext) GetMedianame() antlr.Token

func (*Backup_databaseContext) GetParser

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

func (*Backup_databaseContext) GetRuleContext

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

func (*Backup_databaseContext) GetStats_percent

func (s *Backup_databaseContext) GetStats_percent() antlr.Token

func (*Backup_databaseContext) INIT

func (*Backup_databaseContext) Id

func (*Backup_databaseContext) IsBackup_databaseContext

func (*Backup_databaseContext) IsBackup_databaseContext()

func (*Backup_databaseContext) KEY

func (*Backup_databaseContext) LOAD

func (*Backup_databaseContext) LR_BRACKET

func (s *Backup_databaseContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Backup_databaseContext) MAXTRANSFER

func (s *Backup_databaseContext) MAXTRANSFER(i int) antlr.TerminalNode

func (*Backup_databaseContext) MEDIADESCRIPTION

func (s *Backup_databaseContext) MEDIADESCRIPTION(i int) antlr.TerminalNode

func (*Backup_databaseContext) MEDIANAME

func (s *Backup_databaseContext) MEDIANAME(i int) antlr.TerminalNode

func (*Backup_databaseContext) MIRROR

func (*Backup_databaseContext) NAME

func (*Backup_databaseContext) NOFORMAT

func (*Backup_databaseContext) NOINIT

func (*Backup_databaseContext) NOREWIND

func (*Backup_databaseContext) NOSKIP

func (*Backup_databaseContext) NOUNLOAD

func (*Backup_databaseContext) NO_CHECKSUM

func (s *Backup_databaseContext) NO_CHECKSUM(i int) antlr.TerminalNode

func (*Backup_databaseContext) NO_COMPRESSION

func (s *Backup_databaseContext) NO_COMPRESSION(i int) antlr.TerminalNode

func (*Backup_databaseContext) READ_WRITE_FILEGROUPS

func (s *Backup_databaseContext) READ_WRITE_FILEGROUPS() antlr.TerminalNode

func (*Backup_databaseContext) RESTART

func (*Backup_databaseContext) RETAINDAYS

func (s *Backup_databaseContext) RETAINDAYS(i int) antlr.TerminalNode

func (*Backup_databaseContext) REWIND

func (*Backup_databaseContext) SERVER

func (*Backup_databaseContext) SKIP_KEYWORD

func (s *Backup_databaseContext) SKIP_KEYWORD(i int) antlr.TerminalNode

func (*Backup_databaseContext) STATS

func (*Backup_databaseContext) STOP_ON_ERROR

func (s *Backup_databaseContext) STOP_ON_ERROR(i int) antlr.TerminalNode

func (*Backup_databaseContext) STRING

func (*Backup_databaseContext) SetBackup_set_name

func (s *Backup_databaseContext) SetBackup_set_name(v IIdContext)

func (*Backup_databaseContext) SetDatabase_name

func (s *Backup_databaseContext) SetDatabase_name(v IIdContext)

func (*Backup_databaseContext) SetEncryptor_name

func (s *Backup_databaseContext) SetEncryptor_name(v IIdContext)

func (*Backup_databaseContext) SetFile_or_filegroup

func (s *Backup_databaseContext) SetFile_or_filegroup(v antlr.Token)

func (*Backup_databaseContext) SetLogical_device_name

func (s *Backup_databaseContext) SetLogical_device_name(v IIdContext)

func (*Backup_databaseContext) SetMedianame

func (s *Backup_databaseContext) SetMedianame(v antlr.Token)

func (*Backup_databaseContext) SetStats_percent

func (s *Backup_databaseContext) SetStats_percent(v antlr.Token)

func (*Backup_databaseContext) TAPE

func (*Backup_databaseContext) TO

func (*Backup_databaseContext) TRIPLE_DES_3KEY

func (s *Backup_databaseContext) TRIPLE_DES_3KEY(i int) antlr.TerminalNode

func (*Backup_databaseContext) ToStringTree

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

func (*Backup_databaseContext) URL

func (*Backup_databaseContext) WITH

type Backup_logContext

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

func NewBackup_logContext

func NewBackup_logContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_logContext

func NewEmptyBackup_logContext

func NewEmptyBackup_logContext() *Backup_logContext

func (*Backup_logContext) AES_128

func (s *Backup_logContext) AES_128(i int) antlr.TerminalNode

func (*Backup_logContext) AES_192

func (s *Backup_logContext) AES_192(i int) antlr.TerminalNode

func (*Backup_logContext) AES_256

func (s *Backup_logContext) AES_256(i int) antlr.TerminalNode

func (*Backup_logContext) ALGORITHM

func (s *Backup_logContext) ALGORITHM(i int) antlr.TerminalNode

func (*Backup_logContext) ASYMMETRIC

func (s *Backup_logContext) ASYMMETRIC(i int) antlr.TerminalNode

func (*Backup_logContext) AllAES_128

func (s *Backup_logContext) AllAES_128() []antlr.TerminalNode

func (*Backup_logContext) AllAES_192

func (s *Backup_logContext) AllAES_192() []antlr.TerminalNode

func (*Backup_logContext) AllAES_256

func (s *Backup_logContext) AllAES_256() []antlr.TerminalNode

func (*Backup_logContext) AllALGORITHM

func (s *Backup_logContext) AllALGORITHM() []antlr.TerminalNode

func (*Backup_logContext) AllASYMMETRIC

func (s *Backup_logContext) AllASYMMETRIC() []antlr.TerminalNode

func (*Backup_logContext) AllBLOCKSIZE

func (s *Backup_logContext) AllBLOCKSIZE() []antlr.TerminalNode

func (*Backup_logContext) AllBUFFERCOUNT

func (s *Backup_logContext) AllBUFFERCOUNT() []antlr.TerminalNode

func (*Backup_logContext) AllCERTIFICATE

func (s *Backup_logContext) AllCERTIFICATE() []antlr.TerminalNode

func (*Backup_logContext) AllCHECKSUM

func (s *Backup_logContext) AllCHECKSUM() []antlr.TerminalNode

func (*Backup_logContext) AllCOMMA

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

func (*Backup_logContext) AllCOMPRESSION

func (s *Backup_logContext) AllCOMPRESSION() []antlr.TerminalNode

func (*Backup_logContext) AllCONTINUE_AFTER_ERROR

func (s *Backup_logContext) AllCONTINUE_AFTER_ERROR() []antlr.TerminalNode

func (*Backup_logContext) AllCOPY_ONLY

func (s *Backup_logContext) AllCOPY_ONLY() []antlr.TerminalNode

func (*Backup_logContext) AllCREDENTIAL

func (s *Backup_logContext) AllCREDENTIAL() []antlr.TerminalNode

func (*Backup_logContext) AllDECIMAL

func (s *Backup_logContext) AllDECIMAL() []antlr.TerminalNode

func (*Backup_logContext) AllDESCRIPTION

func (s *Backup_logContext) AllDESCRIPTION() []antlr.TerminalNode

func (*Backup_logContext) AllDIFFERENTIAL

func (s *Backup_logContext) AllDIFFERENTIAL() []antlr.TerminalNode

func (*Backup_logContext) AllDISK

func (s *Backup_logContext) AllDISK() []antlr.TerminalNode

func (*Backup_logContext) AllENCRYPTION

func (s *Backup_logContext) AllENCRYPTION() []antlr.TerminalNode

func (*Backup_logContext) AllEQUAL

func (s *Backup_logContext) AllEQUAL() []antlr.TerminalNode

func (*Backup_logContext) AllEXPIREDATE

func (s *Backup_logContext) AllEXPIREDATE() []antlr.TerminalNode

func (*Backup_logContext) AllFILE_SNAPSHOT

func (s *Backup_logContext) AllFILE_SNAPSHOT() []antlr.TerminalNode

func (*Backup_logContext) AllFORMAT

func (s *Backup_logContext) AllFORMAT() []antlr.TerminalNode

func (*Backup_logContext) AllINIT

func (s *Backup_logContext) AllINIT() []antlr.TerminalNode

func (*Backup_logContext) AllId

func (s *Backup_logContext) AllId() []IIdContext

func (*Backup_logContext) AllKEY

func (s *Backup_logContext) AllKEY() []antlr.TerminalNode

func (*Backup_logContext) AllLOAD

func (s *Backup_logContext) AllLOAD() []antlr.TerminalNode

func (*Backup_logContext) AllLR_BRACKET

func (s *Backup_logContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Backup_logContext) AllMAXTRANSFER

func (s *Backup_logContext) AllMAXTRANSFER() []antlr.TerminalNode

func (*Backup_logContext) AllMEDIADESCRIPTION

func (s *Backup_logContext) AllMEDIADESCRIPTION() []antlr.TerminalNode

func (*Backup_logContext) AllMEDIANAME

func (s *Backup_logContext) AllMEDIANAME() []antlr.TerminalNode

func (*Backup_logContext) AllMIRROR

func (s *Backup_logContext) AllMIRROR() []antlr.TerminalNode

func (*Backup_logContext) AllNAME

func (s *Backup_logContext) AllNAME() []antlr.TerminalNode

func (*Backup_logContext) AllNOFORMAT

func (s *Backup_logContext) AllNOFORMAT() []antlr.TerminalNode

func (*Backup_logContext) AllNOINIT

func (s *Backup_logContext) AllNOINIT() []antlr.TerminalNode

func (*Backup_logContext) AllNORECOVERY

func (s *Backup_logContext) AllNORECOVERY() []antlr.TerminalNode

func (*Backup_logContext) AllNOREWIND

func (s *Backup_logContext) AllNOREWIND() []antlr.TerminalNode

func (*Backup_logContext) AllNOSKIP

func (s *Backup_logContext) AllNOSKIP() []antlr.TerminalNode

func (*Backup_logContext) AllNOUNLOAD

func (s *Backup_logContext) AllNOUNLOAD() []antlr.TerminalNode

func (*Backup_logContext) AllNO_CHECKSUM

func (s *Backup_logContext) AllNO_CHECKSUM() []antlr.TerminalNode

func (*Backup_logContext) AllNO_COMPRESSION

func (s *Backup_logContext) AllNO_COMPRESSION() []antlr.TerminalNode

func (*Backup_logContext) AllNO_TRUNCATE

func (s *Backup_logContext) AllNO_TRUNCATE() []antlr.TerminalNode

func (*Backup_logContext) AllRESTART

func (s *Backup_logContext) AllRESTART() []antlr.TerminalNode

func (*Backup_logContext) AllRETAINDAYS

func (s *Backup_logContext) AllRETAINDAYS() []antlr.TerminalNode

func (*Backup_logContext) AllREWIND

func (s *Backup_logContext) AllREWIND() []antlr.TerminalNode

func (*Backup_logContext) AllSERVER

func (s *Backup_logContext) AllSERVER() []antlr.TerminalNode

func (*Backup_logContext) AllSKIP_KEYWORD

func (s *Backup_logContext) AllSKIP_KEYWORD() []antlr.TerminalNode

func (*Backup_logContext) AllSTANDBY

func (s *Backup_logContext) AllSTANDBY() []antlr.TerminalNode

func (*Backup_logContext) AllSTATS

func (s *Backup_logContext) AllSTATS() []antlr.TerminalNode

func (*Backup_logContext) AllSTOP_ON_ERROR

func (s *Backup_logContext) AllSTOP_ON_ERROR() []antlr.TerminalNode

func (*Backup_logContext) AllSTRING

func (s *Backup_logContext) AllSTRING() []antlr.TerminalNode

func (*Backup_logContext) AllTAPE

func (s *Backup_logContext) AllTAPE() []antlr.TerminalNode

func (*Backup_logContext) AllTO

func (s *Backup_logContext) AllTO() []antlr.TerminalNode

func (*Backup_logContext) AllTRIPLE_DES_3KEY

func (s *Backup_logContext) AllTRIPLE_DES_3KEY() []antlr.TerminalNode

func (*Backup_logContext) AllURL

func (s *Backup_logContext) AllURL() []antlr.TerminalNode

func (*Backup_logContext) BACKUP

func (s *Backup_logContext) BACKUP() antlr.TerminalNode

func (*Backup_logContext) BLOCKSIZE

func (s *Backup_logContext) BLOCKSIZE(i int) antlr.TerminalNode

func (*Backup_logContext) BUFFERCOUNT

func (s *Backup_logContext) BUFFERCOUNT(i int) antlr.TerminalNode

func (*Backup_logContext) CERTIFICATE

func (s *Backup_logContext) CERTIFICATE(i int) antlr.TerminalNode

func (*Backup_logContext) CHECKSUM

func (s *Backup_logContext) CHECKSUM(i int) antlr.TerminalNode

func (*Backup_logContext) COMMA

func (*Backup_logContext) COMPRESSION

func (s *Backup_logContext) COMPRESSION(i int) antlr.TerminalNode

func (*Backup_logContext) CONTINUE_AFTER_ERROR

func (s *Backup_logContext) CONTINUE_AFTER_ERROR(i int) antlr.TerminalNode

func (*Backup_logContext) COPY_ONLY

func (s *Backup_logContext) COPY_ONLY(i int) antlr.TerminalNode

func (*Backup_logContext) CREDENTIAL

func (s *Backup_logContext) CREDENTIAL(i int) antlr.TerminalNode

func (*Backup_logContext) DECIMAL

func (s *Backup_logContext) DECIMAL(i int) antlr.TerminalNode

func (*Backup_logContext) DESCRIPTION

func (s *Backup_logContext) DESCRIPTION(i int) antlr.TerminalNode

func (*Backup_logContext) DIFFERENTIAL

func (s *Backup_logContext) DIFFERENTIAL(i int) antlr.TerminalNode

func (*Backup_logContext) DISK

func (*Backup_logContext) ENCRYPTION

func (s *Backup_logContext) ENCRYPTION(i int) antlr.TerminalNode

func (*Backup_logContext) EQUAL

func (*Backup_logContext) EXPIREDATE

func (s *Backup_logContext) EXPIREDATE(i int) antlr.TerminalNode

func (*Backup_logContext) EnterRule

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

func (*Backup_logContext) ExitRule

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

func (*Backup_logContext) FILE_SNAPSHOT

func (s *Backup_logContext) FILE_SNAPSHOT(i int) antlr.TerminalNode

func (*Backup_logContext) FORMAT

func (s *Backup_logContext) FORMAT(i int) antlr.TerminalNode

func (*Backup_logContext) GetBackup_set_name

func (s *Backup_logContext) GetBackup_set_name() IIdContext

func (*Backup_logContext) GetDatabase_name

func (s *Backup_logContext) GetDatabase_name() IIdContext

func (*Backup_logContext) GetEncryptor_name

func (s *Backup_logContext) GetEncryptor_name() IIdContext

func (*Backup_logContext) GetLogical_device_name

func (s *Backup_logContext) GetLogical_device_name() IIdContext

func (*Backup_logContext) GetMedianame

func (s *Backup_logContext) GetMedianame() antlr.Token

func (*Backup_logContext) GetParser

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

func (*Backup_logContext) GetRuleContext

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

func (*Backup_logContext) GetStats_percent

func (s *Backup_logContext) GetStats_percent() antlr.Token

func (*Backup_logContext) GetUndo_file_name

func (s *Backup_logContext) GetUndo_file_name() antlr.Token

func (*Backup_logContext) INIT

func (*Backup_logContext) Id

func (s *Backup_logContext) Id(i int) IIdContext

func (*Backup_logContext) IsBackup_logContext

func (*Backup_logContext) IsBackup_logContext()

func (*Backup_logContext) KEY

func (*Backup_logContext) LOAD

func (*Backup_logContext) LOG

func (*Backup_logContext) LR_BRACKET

func (s *Backup_logContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Backup_logContext) MAXTRANSFER

func (s *Backup_logContext) MAXTRANSFER(i int) antlr.TerminalNode

func (*Backup_logContext) MEDIADESCRIPTION

func (s *Backup_logContext) MEDIADESCRIPTION(i int) antlr.TerminalNode

func (*Backup_logContext) MEDIANAME

func (s *Backup_logContext) MEDIANAME(i int) antlr.TerminalNode

func (*Backup_logContext) MIRROR

func (s *Backup_logContext) MIRROR(i int) antlr.TerminalNode

func (*Backup_logContext) NAME

func (*Backup_logContext) NOFORMAT

func (s *Backup_logContext) NOFORMAT(i int) antlr.TerminalNode

func (*Backup_logContext) NOINIT

func (s *Backup_logContext) NOINIT(i int) antlr.TerminalNode

func (*Backup_logContext) NORECOVERY

func (s *Backup_logContext) NORECOVERY(i int) antlr.TerminalNode

func (*Backup_logContext) NOREWIND

func (s *Backup_logContext) NOREWIND(i int) antlr.TerminalNode

func (*Backup_logContext) NOSKIP

func (s *Backup_logContext) NOSKIP(i int) antlr.TerminalNode

func (*Backup_logContext) NOUNLOAD

func (s *Backup_logContext) NOUNLOAD(i int) antlr.TerminalNode

func (*Backup_logContext) NO_CHECKSUM

func (s *Backup_logContext) NO_CHECKSUM(i int) antlr.TerminalNode

func (*Backup_logContext) NO_COMPRESSION

func (s *Backup_logContext) NO_COMPRESSION(i int) antlr.TerminalNode

func (*Backup_logContext) NO_TRUNCATE

func (s *Backup_logContext) NO_TRUNCATE(i int) antlr.TerminalNode

func (*Backup_logContext) RESTART

func (s *Backup_logContext) RESTART(i int) antlr.TerminalNode

func (*Backup_logContext) RETAINDAYS

func (s *Backup_logContext) RETAINDAYS(i int) antlr.TerminalNode

func (*Backup_logContext) REWIND

func (s *Backup_logContext) REWIND(i int) antlr.TerminalNode

func (*Backup_logContext) SERVER

func (s *Backup_logContext) SERVER(i int) antlr.TerminalNode

func (*Backup_logContext) SKIP_KEYWORD

func (s *Backup_logContext) SKIP_KEYWORD(i int) antlr.TerminalNode

func (*Backup_logContext) STANDBY

func (s *Backup_logContext) STANDBY(i int) antlr.TerminalNode

func (*Backup_logContext) STATS

func (*Backup_logContext) STOP_ON_ERROR

func (s *Backup_logContext) STOP_ON_ERROR(i int) antlr.TerminalNode

func (*Backup_logContext) STRING

func (s *Backup_logContext) STRING(i int) antlr.TerminalNode

func (*Backup_logContext) SetBackup_set_name

func (s *Backup_logContext) SetBackup_set_name(v IIdContext)

func (*Backup_logContext) SetDatabase_name

func (s *Backup_logContext) SetDatabase_name(v IIdContext)

func (*Backup_logContext) SetEncryptor_name

func (s *Backup_logContext) SetEncryptor_name(v IIdContext)

func (*Backup_logContext) SetLogical_device_name

func (s *Backup_logContext) SetLogical_device_name(v IIdContext)

func (*Backup_logContext) SetMedianame

func (s *Backup_logContext) SetMedianame(v antlr.Token)

func (*Backup_logContext) SetStats_percent

func (s *Backup_logContext) SetStats_percent(v antlr.Token)

func (*Backup_logContext) SetUndo_file_name

func (s *Backup_logContext) SetUndo_file_name(v antlr.Token)

func (*Backup_logContext) TAPE

func (*Backup_logContext) TO

func (*Backup_logContext) TRIPLE_DES_3KEY

func (s *Backup_logContext) TRIPLE_DES_3KEY(i int) antlr.TerminalNode

func (*Backup_logContext) ToStringTree

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

func (*Backup_logContext) URL

func (*Backup_logContext) WITH

type Backup_master_keyContext

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

func NewBackup_master_keyContext

func NewBackup_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_master_keyContext

func NewEmptyBackup_master_keyContext

func NewEmptyBackup_master_keyContext() *Backup_master_keyContext

func (*Backup_master_keyContext) AllEQUAL

func (*Backup_master_keyContext) AllSTRING

func (s *Backup_master_keyContext) AllSTRING() []antlr.TerminalNode

func (*Backup_master_keyContext) BACKUP

func (*Backup_master_keyContext) BY

func (*Backup_master_keyContext) ENCRYPTION

func (*Backup_master_keyContext) EQUAL

func (*Backup_master_keyContext) EnterRule

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

func (*Backup_master_keyContext) ExitRule

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

func (*Backup_master_keyContext) FILE

func (*Backup_master_keyContext) GetEncryption_password

func (s *Backup_master_keyContext) GetEncryption_password() antlr.Token

func (*Backup_master_keyContext) GetMaster_key_backup_file

func (s *Backup_master_keyContext) GetMaster_key_backup_file() antlr.Token

func (*Backup_master_keyContext) GetParser

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

func (*Backup_master_keyContext) GetRuleContext

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

func (*Backup_master_keyContext) IsBackup_master_keyContext

func (*Backup_master_keyContext) IsBackup_master_keyContext()

func (*Backup_master_keyContext) KEY

func (*Backup_master_keyContext) MASTER

func (*Backup_master_keyContext) PASSWORD

func (*Backup_master_keyContext) STRING

func (*Backup_master_keyContext) SetEncryption_password

func (s *Backup_master_keyContext) SetEncryption_password(v antlr.Token)

func (*Backup_master_keyContext) SetMaster_key_backup_file

func (s *Backup_master_keyContext) SetMaster_key_backup_file(v antlr.Token)

func (*Backup_master_keyContext) TO

func (*Backup_master_keyContext) ToStringTree

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

type Backup_service_master_keyContext

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

func NewBackup_service_master_keyContext

func NewBackup_service_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_service_master_keyContext

func NewEmptyBackup_service_master_keyContext

func NewEmptyBackup_service_master_keyContext() *Backup_service_master_keyContext

func (*Backup_service_master_keyContext) AllEQUAL

func (*Backup_service_master_keyContext) AllSTRING

func (*Backup_service_master_keyContext) BACKUP

func (*Backup_service_master_keyContext) BY

func (*Backup_service_master_keyContext) ENCRYPTION

func (*Backup_service_master_keyContext) EQUAL

func (*Backup_service_master_keyContext) EnterRule

func (*Backup_service_master_keyContext) ExitRule

func (*Backup_service_master_keyContext) FILE

func (*Backup_service_master_keyContext) GetEncryption_password

func (s *Backup_service_master_keyContext) GetEncryption_password() antlr.Token

func (*Backup_service_master_keyContext) GetParser

func (*Backup_service_master_keyContext) GetRuleContext

func (*Backup_service_master_keyContext) GetService_master_key_backup_file

func (s *Backup_service_master_keyContext) GetService_master_key_backup_file() antlr.Token

func (*Backup_service_master_keyContext) IsBackup_service_master_keyContext

func (*Backup_service_master_keyContext) IsBackup_service_master_keyContext()

func (*Backup_service_master_keyContext) KEY

func (*Backup_service_master_keyContext) MASTER

func (*Backup_service_master_keyContext) PASSWORD

func (*Backup_service_master_keyContext) SERVICE

func (*Backup_service_master_keyContext) STRING

func (*Backup_service_master_keyContext) SetEncryption_password

func (s *Backup_service_master_keyContext) SetEncryption_password(v antlr.Token)

func (*Backup_service_master_keyContext) SetService_master_key_backup_file

func (s *Backup_service_master_keyContext) SetService_master_key_backup_file(v antlr.Token)

func (*Backup_service_master_keyContext) TO

func (*Backup_service_master_keyContext) ToStringTree

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

type Backup_statementContext

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

func NewBackup_statementContext

func NewBackup_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_statementContext

func NewEmptyBackup_statementContext

func NewEmptyBackup_statementContext() *Backup_statementContext

func (*Backup_statementContext) Backup_certificate

func (s *Backup_statementContext) Backup_certificate() IBackup_certificateContext

func (*Backup_statementContext) Backup_database

func (s *Backup_statementContext) Backup_database() IBackup_databaseContext

func (*Backup_statementContext) Backup_log

func (*Backup_statementContext) Backup_master_key

func (s *Backup_statementContext) Backup_master_key() IBackup_master_keyContext

func (*Backup_statementContext) Backup_service_master_key

func (s *Backup_statementContext) Backup_service_master_key() IBackup_service_master_keyContext

func (*Backup_statementContext) EnterRule

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

func (*Backup_statementContext) ExitRule

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

func (*Backup_statementContext) GetParser

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

func (*Backup_statementContext) GetRuleContext

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

func (*Backup_statementContext) IsBackup_statementContext

func (*Backup_statementContext) IsBackup_statementContext()

func (*Backup_statementContext) ToStringTree

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

type BatchContext

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

func NewBatchContext

func NewBatchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BatchContext

func NewEmptyBatchContext

func NewEmptyBatchContext() *BatchContext

func (*BatchContext) AllGo_statement

func (s *BatchContext) AllGo_statement() []IGo_statementContext

func (*BatchContext) EnterRule

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

func (*BatchContext) Execute_body

func (s *BatchContext) Execute_body() IExecute_bodyContext

func (*BatchContext) ExitRule

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

func (*BatchContext) GetParser

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

func (*BatchContext) GetRuleContext

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

func (*BatchContext) Go_statement

func (s *BatchContext) Go_statement(i int) IGo_statementContext

func (*BatchContext) IsBatchContext

func (*BatchContext) IsBatchContext()

func (*BatchContext) Sql_clauses

func (s *BatchContext) Sql_clauses() ISql_clausesContext

func (*BatchContext) ToStringTree

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

type Begin_conversation_dialogContext

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

func NewBegin_conversation_dialogContext

func NewBegin_conversation_dialogContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_conversation_dialogContext

func NewEmptyBegin_conversation_dialogContext

func NewEmptyBegin_conversation_dialogContext() *Begin_conversation_dialogContext

func (*Begin_conversation_dialogContext) AllCOMMA

func (*Begin_conversation_dialogContext) AllEQUAL

func (*Begin_conversation_dialogContext) AllLOCAL_ID

func (*Begin_conversation_dialogContext) AllON

func (*Begin_conversation_dialogContext) AllSERVICE

func (*Begin_conversation_dialogContext) AllService_name

func (*Begin_conversation_dialogContext) BEGIN

func (*Begin_conversation_dialogContext) COMMA

func (*Begin_conversation_dialogContext) CONTRACT

func (*Begin_conversation_dialogContext) CONVERSATION

func (*Begin_conversation_dialogContext) Contract_name

func (*Begin_conversation_dialogContext) DECIMAL

func (*Begin_conversation_dialogContext) DIALOG

func (*Begin_conversation_dialogContext) ENCRYPTION

func (*Begin_conversation_dialogContext) EQUAL

func (*Begin_conversation_dialogContext) EnterRule

func (*Begin_conversation_dialogContext) ExitRule

func (*Begin_conversation_dialogContext) FROM

func (*Begin_conversation_dialogContext) GetDialog_handle

func (s *Begin_conversation_dialogContext) GetDialog_handle() antlr.Token

func (*Begin_conversation_dialogContext) GetInitiator_service_name

func (s *Begin_conversation_dialogContext) GetInitiator_service_name() IService_nameContext

func (*Begin_conversation_dialogContext) GetParser

func (*Begin_conversation_dialogContext) GetRuleContext

func (*Begin_conversation_dialogContext) GetService_broker_guid

func (s *Begin_conversation_dialogContext) GetService_broker_guid() antlr.Token

func (*Begin_conversation_dialogContext) GetTarget_service_name

func (s *Begin_conversation_dialogContext) GetTarget_service_name() IService_nameContext

func (*Begin_conversation_dialogContext) IsBegin_conversation_dialogContext

func (*Begin_conversation_dialogContext) IsBegin_conversation_dialogContext()

func (*Begin_conversation_dialogContext) LIFETIME

func (*Begin_conversation_dialogContext) LOCAL_ID

func (*Begin_conversation_dialogContext) OFF

func (*Begin_conversation_dialogContext) ON

func (*Begin_conversation_dialogContext) RELATED_CONVERSATION

func (s *Begin_conversation_dialogContext) RELATED_CONVERSATION() antlr.TerminalNode

func (*Begin_conversation_dialogContext) RELATED_CONVERSATION_GROUP

func (s *Begin_conversation_dialogContext) RELATED_CONVERSATION_GROUP() antlr.TerminalNode

func (*Begin_conversation_dialogContext) SEMI

func (*Begin_conversation_dialogContext) SERVICE

func (*Begin_conversation_dialogContext) STRING

func (*Begin_conversation_dialogContext) Service_name

func (*Begin_conversation_dialogContext) SetDialog_handle

func (s *Begin_conversation_dialogContext) SetDialog_handle(v antlr.Token)

func (*Begin_conversation_dialogContext) SetInitiator_service_name

func (s *Begin_conversation_dialogContext) SetInitiator_service_name(v IService_nameContext)

func (*Begin_conversation_dialogContext) SetService_broker_guid

func (s *Begin_conversation_dialogContext) SetService_broker_guid(v antlr.Token)

func (*Begin_conversation_dialogContext) SetTarget_service_name

func (s *Begin_conversation_dialogContext) SetTarget_service_name(v IService_nameContext)

func (*Begin_conversation_dialogContext) TO

func (*Begin_conversation_dialogContext) ToStringTree

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

func (*Begin_conversation_dialogContext) WITH

type Begin_conversation_timerContext

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

func NewBegin_conversation_timerContext

func NewBegin_conversation_timerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_conversation_timerContext

func NewEmptyBegin_conversation_timerContext

func NewEmptyBegin_conversation_timerContext() *Begin_conversation_timerContext

func (*Begin_conversation_timerContext) BEGIN

func (*Begin_conversation_timerContext) CONVERSATION

func (*Begin_conversation_timerContext) EQUAL

func (*Begin_conversation_timerContext) EnterRule

func (*Begin_conversation_timerContext) ExitRule

func (*Begin_conversation_timerContext) GetParser

func (*Begin_conversation_timerContext) GetRuleContext

func (*Begin_conversation_timerContext) IsBegin_conversation_timerContext

func (*Begin_conversation_timerContext) IsBegin_conversation_timerContext()

func (*Begin_conversation_timerContext) LOCAL_ID

func (*Begin_conversation_timerContext) LR_BRACKET

func (*Begin_conversation_timerContext) RR_BRACKET

func (*Begin_conversation_timerContext) SEMI

func (*Begin_conversation_timerContext) TIMEOUT

func (*Begin_conversation_timerContext) TIMER

func (*Begin_conversation_timerContext) Time

func (*Begin_conversation_timerContext) ToStringTree

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

type Block_statementContext

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

func NewBlock_statementContext

func NewBlock_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Block_statementContext

func NewEmptyBlock_statementContext

func NewEmptyBlock_statementContext() *Block_statementContext

func (*Block_statementContext) AllSEMI

func (s *Block_statementContext) AllSEMI() []antlr.TerminalNode

func (*Block_statementContext) BEGIN

func (*Block_statementContext) END

func (*Block_statementContext) EnterRule

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

func (*Block_statementContext) ExitRule

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

func (*Block_statementContext) GetParser

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

func (*Block_statementContext) GetRuleContext

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

func (*Block_statementContext) IsBlock_statementContext

func (*Block_statementContext) IsBlock_statementContext()

func (*Block_statementContext) SEMI

func (*Block_statementContext) Sql_clauses

func (*Block_statementContext) ToStringTree

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

type Bracket_expressionContext

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

func NewBracket_expressionContext

func NewBracket_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bracket_expressionContext

func NewEmptyBracket_expressionContext

func NewEmptyBracket_expressionContext() *Bracket_expressionContext

func (*Bracket_expressionContext) EnterRule

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

func (*Bracket_expressionContext) ExitRule

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

func (*Bracket_expressionContext) Expression

func (*Bracket_expressionContext) GetParser

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

func (*Bracket_expressionContext) GetRuleContext

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

func (*Bracket_expressionContext) IsBracket_expressionContext

func (*Bracket_expressionContext) IsBracket_expressionContext()

func (*Bracket_expressionContext) LR_BRACKET

func (*Bracket_expressionContext) RR_BRACKET

func (*Bracket_expressionContext) Subquery

func (*Bracket_expressionContext) ToStringTree

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

type Break_statementContext

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

func NewBreak_statementContext

func NewBreak_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Break_statementContext

func NewEmptyBreak_statementContext

func NewEmptyBreak_statementContext() *Break_statementContext

func (*Break_statementContext) BREAK

func (*Break_statementContext) EnterRule

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

func (*Break_statementContext) ExitRule

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

func (*Break_statementContext) GetParser

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

func (*Break_statementContext) GetRuleContext

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

func (*Break_statementContext) IsBreak_statementContext

func (*Break_statementContext) IsBreak_statementContext()

func (*Break_statementContext) SEMI

func (*Break_statementContext) ToStringTree

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

type Bulk_optionContext

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

func NewBulk_optionContext

func NewBulk_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bulk_optionContext

func NewEmptyBulk_optionContext

func NewEmptyBulk_optionContext() *Bulk_optionContext

func (*Bulk_optionContext) DECIMAL

func (s *Bulk_optionContext) DECIMAL() antlr.TerminalNode

func (*Bulk_optionContext) EQUAL

func (*Bulk_optionContext) EnterRule

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

func (*Bulk_optionContext) ExitRule

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

func (*Bulk_optionContext) GetBulk_option_value

func (s *Bulk_optionContext) GetBulk_option_value() antlr.Token

func (*Bulk_optionContext) GetParser

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

func (*Bulk_optionContext) GetRuleContext

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

func (*Bulk_optionContext) Id

func (*Bulk_optionContext) IsBulk_optionContext

func (*Bulk_optionContext) IsBulk_optionContext()

func (*Bulk_optionContext) STRING

func (*Bulk_optionContext) SetBulk_option_value

func (s *Bulk_optionContext) SetBulk_option_value(v antlr.Token)

func (*Bulk_optionContext) ToStringTree

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

type CASTContext

type CASTContext struct {
	*Function_callContext
}

func NewCASTContext

func NewCASTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CASTContext

func (*CASTContext) AS

func (s *CASTContext) AS() antlr.TerminalNode

func (*CASTContext) CAST

func (s *CASTContext) CAST() antlr.TerminalNode

func (*CASTContext) Data_type

func (s *CASTContext) Data_type() IData_typeContext

func (*CASTContext) EnterRule

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

func (*CASTContext) ExitRule

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

func (*CASTContext) Expression

func (s *CASTContext) Expression() IExpressionContext

func (*CASTContext) GetRuleContext

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

func (*CASTContext) LR_BRACKET

func (s *CASTContext) LR_BRACKET() antlr.TerminalNode

func (*CASTContext) RR_BRACKET

func (s *CASTContext) RR_BRACKET() antlr.TerminalNode

type CHECKSUMContext

type CHECKSUMContext struct {
	*Function_callContext
}

func NewCHECKSUMContext

func NewCHECKSUMContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CHECKSUMContext

func (*CHECKSUMContext) CHECKSUM

func (s *CHECKSUMContext) CHECKSUM() antlr.TerminalNode

func (*CHECKSUMContext) EnterRule

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

func (*CHECKSUMContext) ExitRule

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

func (*CHECKSUMContext) GetRuleContext

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

func (*CHECKSUMContext) LR_BRACKET

func (s *CHECKSUMContext) LR_BRACKET() antlr.TerminalNode

func (*CHECKSUMContext) RR_BRACKET

func (s *CHECKSUMContext) RR_BRACKET() antlr.TerminalNode

func (*CHECKSUMContext) STAR

type COALESCEContext

type COALESCEContext struct {
	*Function_callContext
}

func NewCOALESCEContext

func NewCOALESCEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *COALESCEContext

func (*COALESCEContext) COALESCE

func (s *COALESCEContext) COALESCE() antlr.TerminalNode

func (*COALESCEContext) EnterRule

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

func (*COALESCEContext) ExitRule

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

func (*COALESCEContext) Expression_list

func (s *COALESCEContext) Expression_list() IExpression_listContext

func (*COALESCEContext) GetRuleContext

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

func (*COALESCEContext) LR_BRACKET

func (s *COALESCEContext) LR_BRACKET() antlr.TerminalNode

func (*COALESCEContext) RR_BRACKET

func (s *COALESCEContext) RR_BRACKET() antlr.TerminalNode

type CONVERTContext

type CONVERTContext struct {
	*Function_callContext
	// contains filtered or unexported fields
}

func NewCONVERTContext

func NewCONVERTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CONVERTContext

func (*CONVERTContext) AllCOMMA

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

func (*CONVERTContext) AllExpression

func (s *CONVERTContext) AllExpression() []IExpressionContext

func (*CONVERTContext) COMMA

func (s *CONVERTContext) COMMA(i int) antlr.TerminalNode

func (*CONVERTContext) CONVERT

func (s *CONVERTContext) CONVERT() antlr.TerminalNode

func (*CONVERTContext) Data_type

func (s *CONVERTContext) Data_type() IData_typeContext

func (*CONVERTContext) EnterRule

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

func (*CONVERTContext) ExitRule

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

func (*CONVERTContext) Expression

func (s *CONVERTContext) Expression(i int) IExpressionContext

func (*CONVERTContext) GetConvert_data_type

func (s *CONVERTContext) GetConvert_data_type() IData_typeContext

func (*CONVERTContext) GetConvert_expression

func (s *CONVERTContext) GetConvert_expression() IExpressionContext

func (*CONVERTContext) GetRuleContext

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

func (*CONVERTContext) GetStyle

func (s *CONVERTContext) GetStyle() IExpressionContext

func (*CONVERTContext) LR_BRACKET

func (s *CONVERTContext) LR_BRACKET() antlr.TerminalNode

func (*CONVERTContext) RR_BRACKET

func (s *CONVERTContext) RR_BRACKET() antlr.TerminalNode

func (*CONVERTContext) SetConvert_data_type

func (s *CONVERTContext) SetConvert_data_type(v IData_typeContext)

func (*CONVERTContext) SetConvert_expression

func (s *CONVERTContext) SetConvert_expression(v IExpressionContext)

func (*CONVERTContext) SetStyle

func (s *CONVERTContext) SetStyle(v IExpressionContext)

type CURRENT_TIMESTAMPContext

type CURRENT_TIMESTAMPContext struct {
	*Function_callContext
}

func NewCURRENT_TIMESTAMPContext

func NewCURRENT_TIMESTAMPContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURRENT_TIMESTAMPContext

func (*CURRENT_TIMESTAMPContext) CURRENT_TIMESTAMP

func (s *CURRENT_TIMESTAMPContext) CURRENT_TIMESTAMP() antlr.TerminalNode

func (*CURRENT_TIMESTAMPContext) EnterRule

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

func (*CURRENT_TIMESTAMPContext) ExitRule

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

func (*CURRENT_TIMESTAMPContext) GetRuleContext

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

type CURRENT_USERContext

type CURRENT_USERContext struct {
	*Function_callContext
}

func NewCURRENT_USERContext

func NewCURRENT_USERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *CURRENT_USERContext

func (*CURRENT_USERContext) CURRENT_USER

func (s *CURRENT_USERContext) CURRENT_USER() antlr.TerminalNode

func (*CURRENT_USERContext) EnterRule

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

func (*CURRENT_USERContext) ExitRule

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

func (*CURRENT_USERContext) GetRuleContext

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

type Case_expressionContext

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

func NewCase_expressionContext

func NewCase_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_expressionContext

func NewEmptyCase_expressionContext

func NewEmptyCase_expressionContext() *Case_expressionContext

func (*Case_expressionContext) AllExpression

func (s *Case_expressionContext) AllExpression() []IExpressionContext

func (*Case_expressionContext) AllSwitch_search_condition_section

func (s *Case_expressionContext) AllSwitch_search_condition_section() []ISwitch_search_condition_sectionContext

func (*Case_expressionContext) AllSwitch_section

func (s *Case_expressionContext) AllSwitch_section() []ISwitch_sectionContext

func (*Case_expressionContext) CASE

func (*Case_expressionContext) ELSE

func (*Case_expressionContext) END

func (*Case_expressionContext) EnterRule

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

func (*Case_expressionContext) ExitRule

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

func (*Case_expressionContext) Expression

func (*Case_expressionContext) GetCaseExpr

func (s *Case_expressionContext) GetCaseExpr() IExpressionContext

func (*Case_expressionContext) GetElseExpr

func (s *Case_expressionContext) GetElseExpr() IExpressionContext

func (*Case_expressionContext) GetParser

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

func (*Case_expressionContext) GetRuleContext

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

func (*Case_expressionContext) IsCase_expressionContext

func (*Case_expressionContext) IsCase_expressionContext()

func (*Case_expressionContext) SetCaseExpr

func (s *Case_expressionContext) SetCaseExpr(v IExpressionContext)

func (*Case_expressionContext) SetElseExpr

func (s *Case_expressionContext) SetElseExpr(v IExpressionContext)

func (*Case_expressionContext) Switch_search_condition_section

func (s *Case_expressionContext) Switch_search_condition_section(i int) ISwitch_search_condition_sectionContext

func (*Case_expressionContext) Switch_section

func (s *Case_expressionContext) Switch_section(i int) ISwitch_sectionContext

func (*Case_expressionContext) ToStringTree

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

type Cfl_statementContext

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

func NewCfl_statementContext

func NewCfl_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cfl_statementContext

func NewEmptyCfl_statementContext

func NewEmptyCfl_statementContext() *Cfl_statementContext

func (*Cfl_statementContext) Block_statement

func (s *Cfl_statementContext) Block_statement() IBlock_statementContext

func (*Cfl_statementContext) Break_statement

func (s *Cfl_statementContext) Break_statement() IBreak_statementContext

func (*Cfl_statementContext) Continue_statement

func (s *Cfl_statementContext) Continue_statement() IContinue_statementContext

func (*Cfl_statementContext) EnterRule

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

func (*Cfl_statementContext) ExitRule

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

func (*Cfl_statementContext) GetParser

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

func (*Cfl_statementContext) GetRuleContext

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

func (*Cfl_statementContext) Goto_statement

func (s *Cfl_statementContext) Goto_statement() IGoto_statementContext

func (*Cfl_statementContext) If_statement

func (s *Cfl_statementContext) If_statement() IIf_statementContext

func (*Cfl_statementContext) IsCfl_statementContext

func (*Cfl_statementContext) IsCfl_statementContext()

func (*Cfl_statementContext) Print_statement

func (s *Cfl_statementContext) Print_statement() IPrint_statementContext

func (*Cfl_statementContext) Raiseerror_statement

func (s *Cfl_statementContext) Raiseerror_statement() IRaiseerror_statementContext

func (*Cfl_statementContext) Return_statement

func (s *Cfl_statementContext) Return_statement() IReturn_statementContext

func (*Cfl_statementContext) Throw_statement

func (s *Cfl_statementContext) Throw_statement() IThrow_statementContext

func (*Cfl_statementContext) ToStringTree

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

func (*Cfl_statementContext) Try_catch_statement

func (s *Cfl_statementContext) Try_catch_statement() ITry_catch_statementContext

func (*Cfl_statementContext) Waitfor_statement

func (s *Cfl_statementContext) Waitfor_statement() IWaitfor_statementContext

func (*Cfl_statementContext) While_statement

func (s *Cfl_statementContext) While_statement() IWhile_statementContext

type Change_tableContext

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

func NewChange_tableContext

func NewChange_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Change_tableContext

func NewEmptyChange_tableContext

func NewEmptyChange_tableContext() *Change_tableContext

func (*Change_tableContext) CHANGES

func (s *Change_tableContext) CHANGES() antlr.TerminalNode

func (*Change_tableContext) CHANGETABLE

func (s *Change_tableContext) CHANGETABLE() antlr.TerminalNode

func (*Change_tableContext) COMMA

func (*Change_tableContext) DECIMAL

func (s *Change_tableContext) DECIMAL() antlr.TerminalNode

func (*Change_tableContext) EnterRule

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

func (*Change_tableContext) ExitRule

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

func (*Change_tableContext) GetParser

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

func (*Change_tableContext) GetRuleContext

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

func (*Change_tableContext) IsChange_tableContext

func (*Change_tableContext) IsChange_tableContext()

func (*Change_tableContext) LOCAL_ID

func (s *Change_tableContext) LOCAL_ID() antlr.TerminalNode

func (*Change_tableContext) LR_BRACKET

func (s *Change_tableContext) LR_BRACKET() antlr.TerminalNode

func (*Change_tableContext) NULL

func (*Change_tableContext) RR_BRACKET

func (s *Change_tableContext) RR_BRACKET() antlr.TerminalNode

func (*Change_tableContext) Table_name

func (s *Change_tableContext) Table_name() ITable_nameContext

func (*Change_tableContext) ToStringTree

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

type Change_tracking_optionContext

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

func NewChange_tracking_optionContext

func NewChange_tracking_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Change_tracking_optionContext

func NewEmptyChange_tracking_optionContext

func NewEmptyChange_tracking_optionContext() *Change_tracking_optionContext

func (*Change_tracking_optionContext) AllCOMMA

func (*Change_tracking_optionContext) AllChange_tracking_option_list

func (s *Change_tracking_optionContext) AllChange_tracking_option_list() []IChange_tracking_option_listContext

func (*Change_tracking_optionContext) CHANGE_TRACKING

func (s *Change_tracking_optionContext) CHANGE_TRACKING() antlr.TerminalNode

func (*Change_tracking_optionContext) COMMA

func (*Change_tracking_optionContext) Change_tracking_option_list

func (s *Change_tracking_optionContext) Change_tracking_option_list(i int) IChange_tracking_option_listContext

func (*Change_tracking_optionContext) EQUAL

func (*Change_tracking_optionContext) EnterRule

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

func (*Change_tracking_optionContext) ExitRule

func (*Change_tracking_optionContext) GetParser

func (*Change_tracking_optionContext) GetRuleContext

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

func (*Change_tracking_optionContext) IsChange_tracking_optionContext

func (*Change_tracking_optionContext) IsChange_tracking_optionContext()

func (*Change_tracking_optionContext) OFF

func (*Change_tracking_optionContext) ON

func (*Change_tracking_optionContext) ToStringTree

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

type Change_tracking_option_listContext

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

func NewChange_tracking_option_listContext

func NewChange_tracking_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Change_tracking_option_listContext

func NewEmptyChange_tracking_option_listContext

func NewEmptyChange_tracking_option_listContext() *Change_tracking_option_listContext

func (*Change_tracking_option_listContext) AUTO_CLEANUP

func (*Change_tracking_option_listContext) CHANGE_RETENTION

func (*Change_tracking_option_listContext) DAYS

func (*Change_tracking_option_listContext) EQUAL

func (*Change_tracking_option_listContext) EnterRule

func (*Change_tracking_option_listContext) ExitRule

func (*Change_tracking_option_listContext) GetParser

func (*Change_tracking_option_listContext) GetRuleContext

func (*Change_tracking_option_listContext) HOURS

func (*Change_tracking_option_listContext) IsChange_tracking_option_listContext

func (*Change_tracking_option_listContext) IsChange_tracking_option_listContext()

func (*Change_tracking_option_listContext) MINUTES

func (*Change_tracking_option_listContext) On_off

func (*Change_tracking_option_listContext) ToStringTree

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

type Class_typeContext

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

func NewClass_typeContext

func NewClass_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Class_typeContext

func NewEmptyClass_typeContext

func NewEmptyClass_typeContext() *Class_typeContext

func (*Class_typeContext) ASSEMBLY

func (s *Class_typeContext) ASSEMBLY() antlr.TerminalNode

func (*Class_typeContext) ASYMMETRIC

func (s *Class_typeContext) ASYMMETRIC() antlr.TerminalNode

func (*Class_typeContext) AVAILABILITY

func (s *Class_typeContext) AVAILABILITY() antlr.TerminalNode

func (*Class_typeContext) BINDING

func (s *Class_typeContext) BINDING() antlr.TerminalNode

func (*Class_typeContext) CATALOG

func (s *Class_typeContext) CATALOG() antlr.TerminalNode

func (*Class_typeContext) CERTIFICATE

func (s *Class_typeContext) CERTIFICATE() antlr.TerminalNode

func (*Class_typeContext) COLLECTION

func (s *Class_typeContext) COLLECTION() antlr.TerminalNode

func (*Class_typeContext) CONTRACT

func (s *Class_typeContext) CONTRACT() antlr.TerminalNode

func (*Class_typeContext) DATABASE

func (s *Class_typeContext) DATABASE() antlr.TerminalNode

func (*Class_typeContext) ENDPOINT

func (s *Class_typeContext) ENDPOINT() antlr.TerminalNode

func (*Class_typeContext) EnterRule

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

func (*Class_typeContext) ExitRule

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

func (*Class_typeContext) FULLTEXT

func (s *Class_typeContext) FULLTEXT() antlr.TerminalNode

func (*Class_typeContext) GROUP

func (*Class_typeContext) GetParser

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

func (*Class_typeContext) GetRuleContext

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

func (*Class_typeContext) IsClass_typeContext

func (*Class_typeContext) IsClass_typeContext()

func (*Class_typeContext) KEY

func (*Class_typeContext) LIST

func (*Class_typeContext) MESSAGE

func (s *Class_typeContext) MESSAGE() antlr.TerminalNode

func (*Class_typeContext) OBJECT

func (s *Class_typeContext) OBJECT() antlr.TerminalNode

func (*Class_typeContext) PROPERTY

func (s *Class_typeContext) PROPERTY() antlr.TerminalNode

func (*Class_typeContext) REMOTE

func (s *Class_typeContext) REMOTE() antlr.TerminalNode

func (*Class_typeContext) ROLE

func (*Class_typeContext) ROUTE

func (*Class_typeContext) SCHEMA

func (s *Class_typeContext) SCHEMA() antlr.TerminalNode

func (*Class_typeContext) SEARCH

func (s *Class_typeContext) SEARCH() antlr.TerminalNode

func (*Class_typeContext) SERVER

func (s *Class_typeContext) SERVER() antlr.TerminalNode

func (*Class_typeContext) SERVICE

func (s *Class_typeContext) SERVICE() antlr.TerminalNode

func (*Class_typeContext) STOPLIST

func (s *Class_typeContext) STOPLIST() antlr.TerminalNode

func (*Class_typeContext) SYMMETRIC

func (s *Class_typeContext) SYMMETRIC() antlr.TerminalNode

func (*Class_typeContext) TYPE

func (*Class_typeContext) ToStringTree

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

func (*Class_typeContext) XML

type Class_type_for_azure_dwContext

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

func NewClass_type_for_azure_dwContext

func NewClass_type_for_azure_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Class_type_for_azure_dwContext

func NewEmptyClass_type_for_azure_dwContext

func NewEmptyClass_type_for_azure_dwContext() *Class_type_for_azure_dwContext

func (*Class_type_for_azure_dwContext) EnterRule

func (*Class_type_for_azure_dwContext) ExitRule

func (*Class_type_for_azure_dwContext) GetParser

func (*Class_type_for_azure_dwContext) GetRuleContext

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

func (*Class_type_for_azure_dwContext) IsClass_type_for_azure_dwContext

func (*Class_type_for_azure_dwContext) IsClass_type_for_azure_dwContext()

func (*Class_type_for_azure_dwContext) OBJECT

func (*Class_type_for_azure_dwContext) SCHEMA

func (*Class_type_for_azure_dwContext) ToStringTree

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

type Class_type_for_parallel_dwContext

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

func NewClass_type_for_parallel_dwContext

func NewClass_type_for_parallel_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Class_type_for_parallel_dwContext

func NewEmptyClass_type_for_parallel_dwContext

func NewEmptyClass_type_for_parallel_dwContext() *Class_type_for_parallel_dwContext

func (*Class_type_for_parallel_dwContext) DATABASE

func (*Class_type_for_parallel_dwContext) EnterRule

func (*Class_type_for_parallel_dwContext) ExitRule

func (*Class_type_for_parallel_dwContext) GetParser

func (*Class_type_for_parallel_dwContext) GetRuleContext

func (*Class_type_for_parallel_dwContext) IsClass_type_for_parallel_dwContext

func (*Class_type_for_parallel_dwContext) IsClass_type_for_parallel_dwContext()

func (*Class_type_for_parallel_dwContext) OBJECT

func (*Class_type_for_parallel_dwContext) SCHEMA

func (*Class_type_for_parallel_dwContext) ToStringTree

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

type Class_type_for_sql_databaseContext

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

func NewClass_type_for_sql_databaseContext

func NewClass_type_for_sql_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Class_type_for_sql_databaseContext

func NewEmptyClass_type_for_sql_databaseContext

func NewEmptyClass_type_for_sql_databaseContext() *Class_type_for_sql_databaseContext

func (*Class_type_for_sql_databaseContext) ASSEMBLY

func (*Class_type_for_sql_databaseContext) ASYMMETRIC

func (*Class_type_for_sql_databaseContext) CATALOG

func (*Class_type_for_sql_databaseContext) CERTIFICATE

func (*Class_type_for_sql_databaseContext) COLLECTION

func (*Class_type_for_sql_databaseContext) DATABASE

func (*Class_type_for_sql_databaseContext) EnterRule

func (*Class_type_for_sql_databaseContext) ExitRule

func (*Class_type_for_sql_databaseContext) FULLTEXT

func (*Class_type_for_sql_databaseContext) GetParser

func (*Class_type_for_sql_databaseContext) GetRuleContext

func (*Class_type_for_sql_databaseContext) IsClass_type_for_sql_databaseContext

func (*Class_type_for_sql_databaseContext) IsClass_type_for_sql_databaseContext()

func (*Class_type_for_sql_databaseContext) KEY

func (*Class_type_for_sql_databaseContext) LIST

func (*Class_type_for_sql_databaseContext) OBJECT

func (*Class_type_for_sql_databaseContext) PROPERTY

func (*Class_type_for_sql_databaseContext) ROLE

func (*Class_type_for_sql_databaseContext) SCHEMA

func (*Class_type_for_sql_databaseContext) SEARCH

func (*Class_type_for_sql_databaseContext) STOPLIST

func (*Class_type_for_sql_databaseContext) SYMMETRIC

func (*Class_type_for_sql_databaseContext) TYPE

func (*Class_type_for_sql_databaseContext) ToStringTree

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

func (*Class_type_for_sql_databaseContext) XML

type Client_assembly_specifierContext

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

func NewClient_assembly_specifierContext

func NewClient_assembly_specifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Client_assembly_specifierContext

func NewEmptyClient_assembly_specifierContext

func NewEmptyClient_assembly_specifierContext() *Client_assembly_specifierContext

func (*Client_assembly_specifierContext) EnterRule

func (*Client_assembly_specifierContext) ExitRule

func (*Client_assembly_specifierContext) GetParser

func (*Client_assembly_specifierContext) GetRuleContext

func (*Client_assembly_specifierContext) IsClient_assembly_specifierContext

func (*Client_assembly_specifierContext) IsClient_assembly_specifierContext()

func (*Client_assembly_specifierContext) Local_file

func (*Client_assembly_specifierContext) Network_file_share

func (*Client_assembly_specifierContext) STRING

func (*Client_assembly_specifierContext) ToStringTree

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

type Close_keyContext

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

func NewClose_keyContext

func NewClose_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Close_keyContext

func NewEmptyClose_keyContext

func NewEmptyClose_keyContext() *Close_keyContext

func (*Close_keyContext) ALL

func (*Close_keyContext) CLOSE

func (s *Close_keyContext) CLOSE() antlr.TerminalNode

func (*Close_keyContext) EnterRule

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

func (*Close_keyContext) ExitRule

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

func (*Close_keyContext) GetKey_name

func (s *Close_keyContext) GetKey_name() IIdContext

func (*Close_keyContext) GetParser

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

func (*Close_keyContext) GetRuleContext

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

func (*Close_keyContext) Id

func (s *Close_keyContext) Id() IIdContext

func (*Close_keyContext) IsClose_keyContext

func (*Close_keyContext) IsClose_keyContext()

func (*Close_keyContext) KEY

func (*Close_keyContext) KEYS

func (*Close_keyContext) MASTER

func (s *Close_keyContext) MASTER() antlr.TerminalNode

func (*Close_keyContext) SYMMETRIC

func (s *Close_keyContext) SYMMETRIC() antlr.TerminalNode

func (*Close_keyContext) SetKey_name

func (s *Close_keyContext) SetKey_name(v IIdContext)

func (*Close_keyContext) ToStringTree

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

type ClusteredContext

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

func NewClusteredContext

func NewClusteredContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusteredContext

func NewEmptyClusteredContext

func NewEmptyClusteredContext() *ClusteredContext

func (*ClusteredContext) CLUSTERED

func (s *ClusteredContext) CLUSTERED() antlr.TerminalNode

func (*ClusteredContext) EnterRule

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

func (*ClusteredContext) ExitRule

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

func (*ClusteredContext) GetParser

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

func (*ClusteredContext) GetRuleContext

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

func (*ClusteredContext) IsClusteredContext

func (*ClusteredContext) IsClusteredContext()

func (*ClusteredContext) NONCLUSTERED

func (s *ClusteredContext) NONCLUSTERED() antlr.TerminalNode

func (*ClusteredContext) ToStringTree

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

type Colon_colonContext

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

func NewColon_colonContext

func NewColon_colonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Colon_colonContext

func NewEmptyColon_colonContext

func NewEmptyColon_colonContext() *Colon_colonContext

func (*Colon_colonContext) AllCOLON

func (s *Colon_colonContext) AllCOLON() []antlr.TerminalNode

func (*Colon_colonContext) COLON

func (*Colon_colonContext) EnterRule

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

func (*Colon_colonContext) ExitRule

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

func (*Colon_colonContext) GetParser

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

func (*Colon_colonContext) GetRuleContext

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

func (*Colon_colonContext) IsColon_colonContext

func (*Colon_colonContext) IsColon_colonContext()

func (*Colon_colonContext) ToStringTree

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

type Column_aliasContext

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

func NewColumn_aliasContext

func NewColumn_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_aliasContext

func NewEmptyColumn_aliasContext

func NewEmptyColumn_aliasContext() *Column_aliasContext

func (*Column_aliasContext) EnterRule

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

func (*Column_aliasContext) ExitRule

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

func (*Column_aliasContext) GetParser

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

func (*Column_aliasContext) GetRuleContext

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

func (*Column_aliasContext) Id

func (*Column_aliasContext) IsColumn_aliasContext

func (*Column_aliasContext) IsColumn_aliasContext()

func (*Column_aliasContext) STRING

func (*Column_aliasContext) ToStringTree

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

type Column_alias_listContext

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

func NewColumn_alias_listContext

func NewColumn_alias_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_alias_listContext

func NewEmptyColumn_alias_listContext

func NewEmptyColumn_alias_listContext() *Column_alias_listContext

func (*Column_alias_listContext) AllCOMMA

func (*Column_alias_listContext) AllColumn_alias

func (s *Column_alias_listContext) AllColumn_alias() []IColumn_aliasContext

func (*Column_alias_listContext) COMMA

func (*Column_alias_listContext) Column_alias

func (*Column_alias_listContext) EnterRule

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

func (*Column_alias_listContext) ExitRule

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

func (*Column_alias_listContext) GetParser

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

func (*Column_alias_listContext) GetRuleContext

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

func (*Column_alias_listContext) IsColumn_alias_listContext

func (*Column_alias_listContext) IsColumn_alias_listContext()

func (*Column_alias_listContext) LR_BRACKET

func (*Column_alias_listContext) RR_BRACKET

func (*Column_alias_listContext) ToStringTree

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

type Column_constraintContext

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

func NewColumn_constraintContext

func NewColumn_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_constraintContext

func NewEmptyColumn_constraintContext

func NewEmptyColumn_constraintContext() *Column_constraintContext

func (*Column_constraintContext) CHECK

func (*Column_constraintContext) CONSTRAINT

func (*Column_constraintContext) Clustered

func (*Column_constraintContext) Column_name_list

func (s *Column_constraintContext) Column_name_list() IColumn_name_listContext

func (*Column_constraintContext) EnterRule

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

func (*Column_constraintContext) ExitRule

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

func (*Column_constraintContext) FOR

func (*Column_constraintContext) FOREIGN

func (*Column_constraintContext) GetConstraint

func (s *Column_constraintContext) GetConstraint() IIdContext

func (*Column_constraintContext) GetParser

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

func (*Column_constraintContext) GetPk

func (*Column_constraintContext) GetRuleContext

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

func (*Column_constraintContext) Id

func (*Column_constraintContext) Index_options

func (*Column_constraintContext) IsColumn_constraintContext

func (*Column_constraintContext) IsColumn_constraintContext()

func (*Column_constraintContext) KEY

func (*Column_constraintContext) LR_BRACKET

func (*Column_constraintContext) NOT

func (*Column_constraintContext) Null_notnull

func (*Column_constraintContext) On_delete

func (*Column_constraintContext) On_update

func (*Column_constraintContext) PRIMARY

func (*Column_constraintContext) REFERENCES

func (*Column_constraintContext) REPLICATION

func (s *Column_constraintContext) REPLICATION() antlr.TerminalNode

func (*Column_constraintContext) RR_BRACKET

func (*Column_constraintContext) Search_condition

func (s *Column_constraintContext) Search_condition() ISearch_conditionContext

func (*Column_constraintContext) SetConstraint

func (s *Column_constraintContext) SetConstraint(v IIdContext)

func (*Column_constraintContext) SetPk

func (*Column_constraintContext) Table_name

func (*Column_constraintContext) ToStringTree

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

func (*Column_constraintContext) UNIQUE

type Column_declarationContext

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

func NewColumn_declarationContext

func NewColumn_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_declarationContext

func NewEmptyColumn_declarationContext

func NewEmptyColumn_declarationContext() *Column_declarationContext

func (*Column_declarationContext) Data_type

func (*Column_declarationContext) EnterRule

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

func (*Column_declarationContext) ExitRule

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

func (*Column_declarationContext) GetParser

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

func (*Column_declarationContext) GetRuleContext

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

func (*Column_declarationContext) ID

func (*Column_declarationContext) IsColumn_declarationContext

func (*Column_declarationContext) IsColumn_declarationContext()

func (*Column_declarationContext) STRING

func (*Column_declarationContext) ToStringTree

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

type Column_def_table_constraintContext

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

func NewColumn_def_table_constraintContext

func NewColumn_def_table_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_def_table_constraintContext

func NewEmptyColumn_def_table_constraintContext

func NewEmptyColumn_def_table_constraintContext() *Column_def_table_constraintContext

func (*Column_def_table_constraintContext) Column_definition

func (*Column_def_table_constraintContext) EnterRule

func (*Column_def_table_constraintContext) ExitRule

func (*Column_def_table_constraintContext) GetParser

func (*Column_def_table_constraintContext) GetRuleContext

func (*Column_def_table_constraintContext) IsColumn_def_table_constraintContext

func (*Column_def_table_constraintContext) IsColumn_def_table_constraintContext()

func (*Column_def_table_constraintContext) Materialized_column_definition

func (*Column_def_table_constraintContext) Table_constraint

func (*Column_def_table_constraintContext) ToStringTree

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

type Column_def_table_constraintsContext

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

func NewColumn_def_table_constraintsContext

func NewColumn_def_table_constraintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_def_table_constraintsContext

func NewEmptyColumn_def_table_constraintsContext

func NewEmptyColumn_def_table_constraintsContext() *Column_def_table_constraintsContext

func (*Column_def_table_constraintsContext) AllCOMMA

func (*Column_def_table_constraintsContext) AllColumn_def_table_constraint

func (s *Column_def_table_constraintsContext) AllColumn_def_table_constraint() []IColumn_def_table_constraintContext

func (*Column_def_table_constraintsContext) COMMA

func (*Column_def_table_constraintsContext) Column_def_table_constraint

func (*Column_def_table_constraintsContext) EnterRule

func (*Column_def_table_constraintsContext) ExitRule

func (*Column_def_table_constraintsContext) GetParser

func (*Column_def_table_constraintsContext) GetRuleContext

func (*Column_def_table_constraintsContext) IsColumn_def_table_constraintsContext

func (*Column_def_table_constraintsContext) IsColumn_def_table_constraintsContext()

func (*Column_def_table_constraintsContext) ToStringTree

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

type Column_definitionContext

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

func NewColumn_definitionContext

func NewColumn_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_definitionContext

func NewEmptyColumn_definitionContext

func NewEmptyColumn_definitionContext() *Column_definitionContext

func (*Column_definitionContext) AS

func (*Column_definitionContext) AllColumn_constraint

func (s *Column_definitionContext) AllColumn_constraint() []IColumn_constraintContext

func (*Column_definitionContext) AllDECIMAL

func (s *Column_definitionContext) AllDECIMAL() []antlr.TerminalNode

func (*Column_definitionContext) AllId

func (s *Column_definitionContext) AllId() []IIdContext

func (*Column_definitionContext) AllNull_or_default

func (s *Column_definitionContext) AllNull_or_default() []INull_or_defaultContext

func (*Column_definitionContext) COLLATE

func (*Column_definitionContext) COMMA

func (*Column_definitionContext) CONSTRAINT

func (*Column_definitionContext) Column_constraint

func (s *Column_definitionContext) Column_constraint(i int) IColumn_constraintContext

func (*Column_definitionContext) DECIMAL

func (*Column_definitionContext) Data_type

func (*Column_definitionContext) EnterRule

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

func (*Column_definitionContext) ExitRule

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

func (*Column_definitionContext) Expression

func (*Column_definitionContext) FOR

func (*Column_definitionContext) GetConstraint

func (s *Column_definitionContext) GetConstraint() IIdContext

func (*Column_definitionContext) GetIncrement

func (s *Column_definitionContext) GetIncrement() antlr.Token

func (*Column_definitionContext) GetParser

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

func (*Column_definitionContext) GetRuleContext

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

func (*Column_definitionContext) GetSeed

func (s *Column_definitionContext) GetSeed() antlr.Token

func (*Column_definitionContext) IDENTITY

func (*Column_definitionContext) Id

func (*Column_definitionContext) IsColumn_definitionContext

func (*Column_definitionContext) IsColumn_definitionContext()

func (*Column_definitionContext) LR_BRACKET

func (*Column_definitionContext) NOT

func (*Column_definitionContext) Null_notnull

func (*Column_definitionContext) Null_or_default

func (*Column_definitionContext) REPLICATION

func (s *Column_definitionContext) REPLICATION() antlr.TerminalNode

func (*Column_definitionContext) ROWGUIDCOL

func (*Column_definitionContext) RR_BRACKET

func (*Column_definitionContext) SetConstraint

func (s *Column_definitionContext) SetConstraint(v IIdContext)

func (*Column_definitionContext) SetIncrement

func (s *Column_definitionContext) SetIncrement(v antlr.Token)

func (*Column_definitionContext) SetSeed

func (s *Column_definitionContext) SetSeed(v antlr.Token)

func (*Column_definitionContext) ToStringTree

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

type Column_elemContext

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

func NewColumn_elemContext

func NewColumn_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_elemContext

func NewEmptyColumn_elemContext

func NewEmptyColumn_elemContext() *Column_elemContext

func (*Column_elemContext) As_column_alias

func (s *Column_elemContext) As_column_alias() IAs_column_aliasContext

func (*Column_elemContext) DOLLAR

func (*Column_elemContext) DOT

func (*Column_elemContext) EnterRule

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

func (*Column_elemContext) ExitRule

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

func (*Column_elemContext) GetColumn_name

func (s *Column_elemContext) GetColumn_name() IIdContext

func (*Column_elemContext) GetParser

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

func (*Column_elemContext) GetRuleContext

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

func (*Column_elemContext) IDENTITY

func (s *Column_elemContext) IDENTITY() antlr.TerminalNode

func (*Column_elemContext) Id

func (*Column_elemContext) IsColumn_elemContext

func (*Column_elemContext) IsColumn_elemContext()

func (*Column_elemContext) ROWGUID

func (s *Column_elemContext) ROWGUID() antlr.TerminalNode

func (*Column_elemContext) SetColumn_name

func (s *Column_elemContext) SetColumn_name(v IIdContext)

func (*Column_elemContext) Table_name

func (s *Column_elemContext) Table_name() ITable_nameContext

func (*Column_elemContext) ToStringTree

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

type Column_name_listContext

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

func NewColumn_name_listContext

func NewColumn_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_name_listContext

func NewEmptyColumn_name_listContext

func NewEmptyColumn_name_listContext() *Column_name_listContext

func (*Column_name_listContext) AllCOMMA

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

func (*Column_name_listContext) AllId

func (s *Column_name_listContext) AllId() []IIdContext

func (*Column_name_listContext) COMMA

func (*Column_name_listContext) EnterRule

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

func (*Column_name_listContext) ExitRule

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

func (*Column_name_listContext) GetParser

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

func (*Column_name_listContext) GetRuleContext

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

func (*Column_name_listContext) Id

func (*Column_name_listContext) IsColumn_name_listContext

func (*Column_name_listContext) IsColumn_name_listContext()

func (*Column_name_listContext) ToStringTree

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

type Column_name_list_with_orderContext

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

func NewColumn_name_list_with_orderContext

func NewColumn_name_list_with_orderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_name_list_with_orderContext

func NewEmptyColumn_name_list_with_orderContext

func NewEmptyColumn_name_list_with_orderContext() *Column_name_list_with_orderContext

func (*Column_name_list_with_orderContext) ASC

func (*Column_name_list_with_orderContext) AllASC

func (*Column_name_list_with_orderContext) AllCOMMA

func (*Column_name_list_with_orderContext) AllDESC

func (*Column_name_list_with_orderContext) AllId

func (*Column_name_list_with_orderContext) COMMA

func (*Column_name_list_with_orderContext) DESC

func (*Column_name_list_with_orderContext) EnterRule

func (*Column_name_list_with_orderContext) ExitRule

func (*Column_name_list_with_orderContext) GetParser

func (*Column_name_list_with_orderContext) GetRuleContext

func (*Column_name_list_with_orderContext) Id

func (*Column_name_list_with_orderContext) IsColumn_name_list_with_orderContext

func (*Column_name_list_with_orderContext) IsColumn_name_list_with_orderContext()

func (*Column_name_list_with_orderContext) ToStringTree

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

type Common_table_expressionContext

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

func NewCommon_table_expressionContext

func NewCommon_table_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_expressionContext

func NewEmptyCommon_table_expressionContext

func NewEmptyCommon_table_expressionContext() *Common_table_expressionContext

func (*Common_table_expressionContext) AS

func (*Common_table_expressionContext) AllLR_BRACKET

func (s *Common_table_expressionContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Common_table_expressionContext) AllRR_BRACKET

func (s *Common_table_expressionContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Common_table_expressionContext) Column_name_list

func (*Common_table_expressionContext) EnterRule

func (*Common_table_expressionContext) ExitRule

func (*Common_table_expressionContext) GetExpression_name

func (s *Common_table_expressionContext) GetExpression_name() IIdContext

func (*Common_table_expressionContext) GetParser

func (*Common_table_expressionContext) GetRuleContext

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

func (*Common_table_expressionContext) Id

func (*Common_table_expressionContext) IsCommon_table_expressionContext

func (*Common_table_expressionContext) IsCommon_table_expressionContext()

func (*Common_table_expressionContext) LR_BRACKET

func (*Common_table_expressionContext) RR_BRACKET

func (*Common_table_expressionContext) Select_statement

func (*Common_table_expressionContext) SetExpression_name

func (s *Common_table_expressionContext) SetExpression_name(v IIdContext)

func (*Common_table_expressionContext) ToStringTree

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

type Comparison_operatorContext

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

func NewComparison_operatorContext

func NewComparison_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comparison_operatorContext

func NewEmptyComparison_operatorContext

func NewEmptyComparison_operatorContext() *Comparison_operatorContext

func (*Comparison_operatorContext) EQUAL

func (*Comparison_operatorContext) EXCLAMATION

func (*Comparison_operatorContext) EnterRule

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

func (*Comparison_operatorContext) ExitRule

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

func (*Comparison_operatorContext) GREATER

func (*Comparison_operatorContext) GetParser

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

func (*Comparison_operatorContext) GetRuleContext

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

func (*Comparison_operatorContext) IsComparison_operatorContext

func (*Comparison_operatorContext) IsComparison_operatorContext()

func (*Comparison_operatorContext) LESS

func (*Comparison_operatorContext) ToStringTree

func (s *Comparison_operatorContext) 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) BINARY

func (s *ConstantContext) BINARY() antlr.TerminalNode

func (*ConstantContext) DECIMAL

func (s *ConstantContext) DECIMAL() antlr.TerminalNode

func (*ConstantContext) DOLLAR

func (s *ConstantContext) DOLLAR() antlr.TerminalNode

func (*ConstantContext) EnterRule

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

func (*ConstantContext) ExitRule

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

func (*ConstantContext) FLOAT

func (s *ConstantContext) FLOAT() antlr.TerminalNode

func (*ConstantContext) GetDollar

func (s *ConstantContext) GetDollar() antlr.Token

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

func (*ConstantContext) STRING

func (s *ConstantContext) STRING() antlr.TerminalNode

func (*ConstantContext) SetDollar

func (s *ConstantContext) SetDollar(v antlr.Token)

func (*ConstantContext) Sign

func (s *ConstantContext) Sign() ISignContext

func (*ConstantContext) ToStringTree

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

type Constant_LOCAL_IDContext

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

func NewConstant_LOCAL_IDContext

func NewConstant_LOCAL_IDContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constant_LOCAL_IDContext

func NewEmptyConstant_LOCAL_IDContext

func NewEmptyConstant_LOCAL_IDContext() *Constant_LOCAL_IDContext

func (*Constant_LOCAL_IDContext) Constant

func (*Constant_LOCAL_IDContext) EnterRule

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

func (*Constant_LOCAL_IDContext) ExitRule

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

func (*Constant_LOCAL_IDContext) GetParser

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

func (*Constant_LOCAL_IDContext) GetRuleContext

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

func (*Constant_LOCAL_IDContext) IsConstant_LOCAL_IDContext

func (*Constant_LOCAL_IDContext) IsConstant_LOCAL_IDContext()

func (*Constant_LOCAL_IDContext) LOCAL_ID

func (*Constant_LOCAL_IDContext) ToStringTree

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

type Constant_expressionContext

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

func NewConstant_expressionContext

func NewConstant_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constant_expressionContext

func NewEmptyConstant_expressionContext

func NewEmptyConstant_expressionContext() *Constant_expressionContext

func (*Constant_expressionContext) Constant

func (*Constant_expressionContext) Constant_expression

func (*Constant_expressionContext) EnterRule

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

func (*Constant_expressionContext) ExitRule

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

func (*Constant_expressionContext) Function_call

func (*Constant_expressionContext) GetParser

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

func (*Constant_expressionContext) GetRuleContext

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

func (*Constant_expressionContext) IsConstant_expressionContext

func (*Constant_expressionContext) IsConstant_expressionContext()

func (*Constant_expressionContext) LOCAL_ID

func (*Constant_expressionContext) LR_BRACKET

func (*Constant_expressionContext) NULL

func (*Constant_expressionContext) RR_BRACKET

func (*Constant_expressionContext) ToStringTree

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

type Containment_optionContext

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

func NewContainment_optionContext

func NewContainment_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Containment_optionContext

func NewEmptyContainment_optionContext

func NewEmptyContainment_optionContext() *Containment_optionContext

func (*Containment_optionContext) CONTAINMENT

func (s *Containment_optionContext) CONTAINMENT() antlr.TerminalNode

func (*Containment_optionContext) EQUAL

func (*Containment_optionContext) EnterRule

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

func (*Containment_optionContext) ExitRule

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

func (*Containment_optionContext) GetParser

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

func (*Containment_optionContext) GetRuleContext

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

func (*Containment_optionContext) IsContainment_optionContext

func (*Containment_optionContext) IsContainment_optionContext()

func (*Containment_optionContext) NONE

func (*Containment_optionContext) PARTIAL

func (*Containment_optionContext) ToStringTree

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

type Continue_statementContext

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

func NewContinue_statementContext

func NewContinue_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Continue_statementContext

func NewEmptyContinue_statementContext

func NewEmptyContinue_statementContext() *Continue_statementContext

func (*Continue_statementContext) CONTINUE

func (*Continue_statementContext) EnterRule

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

func (*Continue_statementContext) ExitRule

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

func (*Continue_statementContext) GetParser

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

func (*Continue_statementContext) GetRuleContext

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

func (*Continue_statementContext) IsContinue_statementContext

func (*Continue_statementContext) IsContinue_statementContext()

func (*Continue_statementContext) SEMI

func (*Continue_statementContext) ToStringTree

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

type Contract_nameContext

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

func NewContract_nameContext

func NewContract_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Contract_nameContext

func NewEmptyContract_nameContext

func NewEmptyContract_nameContext() *Contract_nameContext

func (*Contract_nameContext) EnterRule

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

func (*Contract_nameContext) ExitRule

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

func (*Contract_nameContext) Expression

func (s *Contract_nameContext) Expression() IExpressionContext

func (*Contract_nameContext) GetParser

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

func (*Contract_nameContext) GetRuleContext

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

func (*Contract_nameContext) Id

func (*Contract_nameContext) IsContract_nameContext

func (*Contract_nameContext) IsContract_nameContext()

func (*Contract_nameContext) ToStringTree

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

type Conversation_statementContext

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

func NewConversation_statementContext

func NewConversation_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conversation_statementContext

func NewEmptyConversation_statementContext

func NewEmptyConversation_statementContext() *Conversation_statementContext

func (*Conversation_statementContext) Begin_conversation_dialog

func (*Conversation_statementContext) Begin_conversation_timer

func (*Conversation_statementContext) End_conversation

func (*Conversation_statementContext) EnterRule

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

func (*Conversation_statementContext) ExitRule

func (*Conversation_statementContext) GetParser

func (*Conversation_statementContext) GetRuleContext

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

func (*Conversation_statementContext) Get_conversation

func (*Conversation_statementContext) IsConversation_statementContext

func (*Conversation_statementContext) IsConversation_statementContext()

func (*Conversation_statementContext) Send_conversation

func (*Conversation_statementContext) ToStringTree

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

func (*Conversation_statementContext) Waitfor_conversation

type Create_application_roleContext

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

func NewCreate_application_roleContext

func NewCreate_application_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_application_roleContext

func NewEmptyCreate_application_roleContext

func NewEmptyCreate_application_roleContext() *Create_application_roleContext

func (*Create_application_roleContext) APPLICATION

func (*Create_application_roleContext) AllCOMMA

func (*Create_application_roleContext) AllEQUAL

func (*Create_application_roleContext) AllId

func (*Create_application_roleContext) COMMA

func (*Create_application_roleContext) CREATE

func (*Create_application_roleContext) DEFAULT_SCHEMA

func (*Create_application_roleContext) EQUAL

func (*Create_application_roleContext) EnterRule

func (*Create_application_roleContext) ExitRule

func (*Create_application_roleContext) GetApp_role_default_schema

func (s *Create_application_roleContext) GetApp_role_default_schema() IIdContext

func (*Create_application_roleContext) GetApplication_role_password

func (s *Create_application_roleContext) GetApplication_role_password() antlr.Token

func (*Create_application_roleContext) GetAppliction_role

func (s *Create_application_roleContext) GetAppliction_role() IIdContext

func (*Create_application_roleContext) GetParser

func (*Create_application_roleContext) GetRuleContext

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

func (*Create_application_roleContext) Id

func (*Create_application_roleContext) IsCreate_application_roleContext

func (*Create_application_roleContext) IsCreate_application_roleContext()

func (*Create_application_roleContext) PASSWORD

func (*Create_application_roleContext) ROLE

func (*Create_application_roleContext) STRING

func (*Create_application_roleContext) SetApp_role_default_schema

func (s *Create_application_roleContext) SetApp_role_default_schema(v IIdContext)

func (*Create_application_roleContext) SetApplication_role_password

func (s *Create_application_roleContext) SetApplication_role_password(v antlr.Token)

func (*Create_application_roleContext) SetAppliction_role

func (s *Create_application_roleContext) SetAppliction_role(v IIdContext)

func (*Create_application_roleContext) ToStringTree

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

func (*Create_application_roleContext) WITH

type Create_assemblyContext

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

func NewCreate_assemblyContext

func NewCreate_assemblyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_assemblyContext

func NewEmptyCreate_assemblyContext

func NewEmptyCreate_assemblyContext() *Create_assemblyContext

func (*Create_assemblyContext) ASSEMBLY

func (*Create_assemblyContext) AUTHORIZATION

func (s *Create_assemblyContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_assemblyContext) AllBINARY

func (s *Create_assemblyContext) AllBINARY() []antlr.TerminalNode

func (*Create_assemblyContext) AllCOMMA

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

func (*Create_assemblyContext) AllId

func (s *Create_assemblyContext) AllId() []IIdContext

func (*Create_assemblyContext) AllSTRING

func (s *Create_assemblyContext) AllSTRING() []antlr.TerminalNode

func (*Create_assemblyContext) BINARY

func (*Create_assemblyContext) COMMA

func (*Create_assemblyContext) CREATE

func (*Create_assemblyContext) EQUAL

func (*Create_assemblyContext) EXTERNAL_ACCESS

func (s *Create_assemblyContext) EXTERNAL_ACCESS() antlr.TerminalNode

func (*Create_assemblyContext) EnterRule

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

func (*Create_assemblyContext) ExitRule

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

func (*Create_assemblyContext) FROM

func (*Create_assemblyContext) GetAssembly_name

func (s *Create_assemblyContext) GetAssembly_name() IIdContext

func (*Create_assemblyContext) GetOwner_name

func (s *Create_assemblyContext) GetOwner_name() IIdContext

func (*Create_assemblyContext) GetParser

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

func (*Create_assemblyContext) GetRuleContext

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

func (*Create_assemblyContext) Id

func (*Create_assemblyContext) IsCreate_assemblyContext

func (*Create_assemblyContext) IsCreate_assemblyContext()

func (*Create_assemblyContext) PERMISSION_SET

func (s *Create_assemblyContext) PERMISSION_SET() antlr.TerminalNode

func (*Create_assemblyContext) SAFE

func (*Create_assemblyContext) STRING

func (*Create_assemblyContext) SetAssembly_name

func (s *Create_assemblyContext) SetAssembly_name(v IIdContext)

func (*Create_assemblyContext) SetOwner_name

func (s *Create_assemblyContext) SetOwner_name(v IIdContext)

func (*Create_assemblyContext) ToStringTree

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

func (*Create_assemblyContext) UNSAFE

func (*Create_assemblyContext) WITH

type Create_asymmetric_keyContext

type Create_asymmetric_keyContext struct {
	*antlr.BaseParserRuleContext

	Asym_Key_Nam IIdContext

	Assembly_Name IIdContext
	Provider_Name IIdContext
	// contains filtered or unexported fields
}

func NewCreate_asymmetric_keyContext

func NewCreate_asymmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_asymmetric_keyContext

func NewEmptyCreate_asymmetric_keyContext

func NewEmptyCreate_asymmetric_keyContext() *Create_asymmetric_keyContext

func (*Create_asymmetric_keyContext) ALGORITHM

func (*Create_asymmetric_keyContext) ASSEMBLY

func (*Create_asymmetric_keyContext) ASYMMETRIC

func (*Create_asymmetric_keyContext) AUTHORIZATION

func (s *Create_asymmetric_keyContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_asymmetric_keyContext) AllEQUAL

func (*Create_asymmetric_keyContext) AllId

func (*Create_asymmetric_keyContext) AllSTRING

func (*Create_asymmetric_keyContext) BY

func (*Create_asymmetric_keyContext) CREATE

func (*Create_asymmetric_keyContext) CREATE_NEW

func (*Create_asymmetric_keyContext) CREATION_DISPOSITION

func (s *Create_asymmetric_keyContext) CREATION_DISPOSITION() antlr.TerminalNode

func (*Create_asymmetric_keyContext) ENCRYPTION

func (*Create_asymmetric_keyContext) EQUAL

func (*Create_asymmetric_keyContext) EXECUTABLE_FILE

func (s *Create_asymmetric_keyContext) EXECUTABLE_FILE() antlr.TerminalNode

func (*Create_asymmetric_keyContext) EnterRule

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

func (*Create_asymmetric_keyContext) ExitRule

func (*Create_asymmetric_keyContext) FILE

func (*Create_asymmetric_keyContext) FROM

func (*Create_asymmetric_keyContext) GetAssembly_Name

func (s *Create_asymmetric_keyContext) GetAssembly_Name() IIdContext

func (*Create_asymmetric_keyContext) GetAsym_Key_Nam

func (s *Create_asymmetric_keyContext) GetAsym_Key_Nam() IIdContext

func (*Create_asymmetric_keyContext) GetAsymmetric_key_password

func (s *Create_asymmetric_keyContext) GetAsymmetric_key_password() antlr.Token

func (*Create_asymmetric_keyContext) GetDatabase_principal_name

func (s *Create_asymmetric_keyContext) GetDatabase_principal_name() IIdContext

func (*Create_asymmetric_keyContext) GetParser

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

func (*Create_asymmetric_keyContext) GetProvider_Name

func (s *Create_asymmetric_keyContext) GetProvider_Name() IIdContext

func (*Create_asymmetric_keyContext) GetProvider_key_name

func (s *Create_asymmetric_keyContext) GetProvider_key_name() antlr.Token

func (*Create_asymmetric_keyContext) GetRuleContext

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

func (*Create_asymmetric_keyContext) Id

func (*Create_asymmetric_keyContext) IsCreate_asymmetric_keyContext

func (*Create_asymmetric_keyContext) IsCreate_asymmetric_keyContext()

func (*Create_asymmetric_keyContext) KEY

func (*Create_asymmetric_keyContext) OPEN_EXISTING

func (s *Create_asymmetric_keyContext) OPEN_EXISTING() antlr.TerminalNode

func (*Create_asymmetric_keyContext) PASSWORD

func (*Create_asymmetric_keyContext) PROVIDER

func (*Create_asymmetric_keyContext) PROVIDER_KEY_NAME

func (s *Create_asymmetric_keyContext) PROVIDER_KEY_NAME() antlr.TerminalNode

func (*Create_asymmetric_keyContext) RSA_1024

func (*Create_asymmetric_keyContext) RSA_2048

func (*Create_asymmetric_keyContext) RSA_3072

func (*Create_asymmetric_keyContext) RSA_4096

func (*Create_asymmetric_keyContext) RSA_512

func (*Create_asymmetric_keyContext) STRING

func (*Create_asymmetric_keyContext) SetAssembly_Name

func (s *Create_asymmetric_keyContext) SetAssembly_Name(v IIdContext)

func (*Create_asymmetric_keyContext) SetAsym_Key_Nam

func (s *Create_asymmetric_keyContext) SetAsym_Key_Nam(v IIdContext)

func (*Create_asymmetric_keyContext) SetAsymmetric_key_password

func (s *Create_asymmetric_keyContext) SetAsymmetric_key_password(v antlr.Token)

func (*Create_asymmetric_keyContext) SetDatabase_principal_name

func (s *Create_asymmetric_keyContext) SetDatabase_principal_name(v IIdContext)

func (*Create_asymmetric_keyContext) SetProvider_Name

func (s *Create_asymmetric_keyContext) SetProvider_Name(v IIdContext)

func (*Create_asymmetric_keyContext) SetProvider_key_name

func (s *Create_asymmetric_keyContext) SetProvider_key_name(v antlr.Token)

func (*Create_asymmetric_keyContext) ToStringTree

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

func (*Create_asymmetric_keyContext) WITH

type Create_certificateContext

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

func NewCreate_certificateContext

func NewCreate_certificateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_certificateContext

func NewEmptyCreate_certificateContext

func NewEmptyCreate_certificateContext() *Create_certificateContext

func (*Create_certificateContext) ACTIVE

func (*Create_certificateContext) AUTHORIZATION

func (s *Create_certificateContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_certificateContext) AllId

func (*Create_certificateContext) BEGIN

func (*Create_certificateContext) CERTIFICATE

func (s *Create_certificateContext) CERTIFICATE() antlr.TerminalNode

func (*Create_certificateContext) CREATE

func (*Create_certificateContext) DIALOG

func (*Create_certificateContext) EQUAL

func (*Create_certificateContext) EnterRule

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

func (*Create_certificateContext) Existing_keys

func (*Create_certificateContext) ExitRule

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

func (*Create_certificateContext) FOR

func (*Create_certificateContext) FROM

func (*Create_certificateContext) Generate_new_keys

func (*Create_certificateContext) GetCertificate_name

func (s *Create_certificateContext) GetCertificate_name() IIdContext

func (*Create_certificateContext) GetParser

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

func (*Create_certificateContext) GetRuleContext

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

func (*Create_certificateContext) GetUser_name

func (s *Create_certificateContext) GetUser_name() IIdContext

func (*Create_certificateContext) Id

func (*Create_certificateContext) IsCreate_certificateContext

func (*Create_certificateContext) IsCreate_certificateContext()

func (*Create_certificateContext) OFF

func (*Create_certificateContext) ON

func (*Create_certificateContext) SetCertificate_name

func (s *Create_certificateContext) SetCertificate_name(v IIdContext)

func (*Create_certificateContext) SetUser_name

func (s *Create_certificateContext) SetUser_name(v IIdContext)

func (*Create_certificateContext) ToStringTree

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

type Create_column_encryption_keyContext

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

func NewCreate_column_encryption_keyContext

func NewCreate_column_encryption_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_column_encryption_keyContext

func NewEmptyCreate_column_encryption_keyContext

func NewEmptyCreate_column_encryption_keyContext() *Create_column_encryption_keyContext

func (*Create_column_encryption_keyContext) ALGORITHM

func (*Create_column_encryption_keyContext) AllALGORITHM

func (*Create_column_encryption_keyContext) AllBINARY

func (*Create_column_encryption_keyContext) AllCOLUMN_MASTER_KEY

func (s *Create_column_encryption_keyContext) AllCOLUMN_MASTER_KEY() []antlr.TerminalNode

func (*Create_column_encryption_keyContext) AllCOMMA

func (*Create_column_encryption_keyContext) AllENCRYPTED_VALUE

func (s *Create_column_encryption_keyContext) AllENCRYPTED_VALUE() []antlr.TerminalNode

func (*Create_column_encryption_keyContext) AllEQUAL

func (*Create_column_encryption_keyContext) AllId

func (*Create_column_encryption_keyContext) AllLR_BRACKET

func (*Create_column_encryption_keyContext) AllRR_BRACKET

func (*Create_column_encryption_keyContext) AllSTRING

func (*Create_column_encryption_keyContext) BINARY

func (*Create_column_encryption_keyContext) COLUMN

func (*Create_column_encryption_keyContext) COLUMN_MASTER_KEY

func (*Create_column_encryption_keyContext) COMMA

func (*Create_column_encryption_keyContext) CREATE

func (*Create_column_encryption_keyContext) ENCRYPTED_VALUE

func (*Create_column_encryption_keyContext) ENCRYPTION

func (*Create_column_encryption_keyContext) EQUAL

func (*Create_column_encryption_keyContext) EnterRule

func (*Create_column_encryption_keyContext) ExitRule

func (*Create_column_encryption_keyContext) GetAlgorithm_name

func (s *Create_column_encryption_keyContext) GetAlgorithm_name() antlr.Token

func (*Create_column_encryption_keyContext) GetColumn_encryption_key

func (s *Create_column_encryption_keyContext) GetColumn_encryption_key() IIdContext

func (*Create_column_encryption_keyContext) GetColumn_master_key_name

func (s *Create_column_encryption_keyContext) GetColumn_master_key_name() IIdContext

func (*Create_column_encryption_keyContext) GetEncrypted_value

func (s *Create_column_encryption_keyContext) GetEncrypted_value() antlr.Token

func (*Create_column_encryption_keyContext) GetParser

func (*Create_column_encryption_keyContext) GetRuleContext

func (*Create_column_encryption_keyContext) Id

func (*Create_column_encryption_keyContext) IsCreate_column_encryption_keyContext

func (*Create_column_encryption_keyContext) IsCreate_column_encryption_keyContext()

func (*Create_column_encryption_keyContext) KEY

func (*Create_column_encryption_keyContext) LR_BRACKET

func (*Create_column_encryption_keyContext) RR_BRACKET

func (*Create_column_encryption_keyContext) STRING

func (*Create_column_encryption_keyContext) SetAlgorithm_name

func (s *Create_column_encryption_keyContext) SetAlgorithm_name(v antlr.Token)

func (*Create_column_encryption_keyContext) SetColumn_encryption_key

func (s *Create_column_encryption_keyContext) SetColumn_encryption_key(v IIdContext)

func (*Create_column_encryption_keyContext) SetColumn_master_key_name

func (s *Create_column_encryption_keyContext) SetColumn_master_key_name(v IIdContext)

func (*Create_column_encryption_keyContext) SetEncrypted_value

func (s *Create_column_encryption_keyContext) SetEncrypted_value(v antlr.Token)

func (*Create_column_encryption_keyContext) ToStringTree

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

func (*Create_column_encryption_keyContext) VALUES

func (*Create_column_encryption_keyContext) WITH

type Create_column_master_keyContext

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

func NewCreate_column_master_keyContext

func NewCreate_column_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_column_master_keyContext

func NewEmptyCreate_column_master_keyContext

func NewEmptyCreate_column_master_keyContext() *Create_column_master_keyContext

func (*Create_column_master_keyContext) AllEQUAL

func (*Create_column_master_keyContext) AllSTRING

func (*Create_column_master_keyContext) COLUMN

func (*Create_column_master_keyContext) COMMA

func (*Create_column_master_keyContext) CREATE

func (*Create_column_master_keyContext) EQUAL

func (*Create_column_master_keyContext) EnterRule

func (*Create_column_master_keyContext) ExitRule

func (*Create_column_master_keyContext) GetKey_name

func (*Create_column_master_keyContext) GetKey_path

func (s *Create_column_master_keyContext) GetKey_path() antlr.Token

func (*Create_column_master_keyContext) GetKey_store_provider_name

func (s *Create_column_master_keyContext) GetKey_store_provider_name() antlr.Token

func (*Create_column_master_keyContext) GetParser

func (*Create_column_master_keyContext) GetRuleContext

func (*Create_column_master_keyContext) Id

func (*Create_column_master_keyContext) IsCreate_column_master_keyContext

func (*Create_column_master_keyContext) IsCreate_column_master_keyContext()

func (*Create_column_master_keyContext) KEY

func (*Create_column_master_keyContext) KEY_PATH

func (*Create_column_master_keyContext) KEY_STORE_PROVIDER_NAME

func (s *Create_column_master_keyContext) KEY_STORE_PROVIDER_NAME() antlr.TerminalNode

func (*Create_column_master_keyContext) LR_BRACKET

func (*Create_column_master_keyContext) MASTER

func (*Create_column_master_keyContext) RR_BRACKET

func (*Create_column_master_keyContext) STRING

func (*Create_column_master_keyContext) SetKey_name

func (s *Create_column_master_keyContext) SetKey_name(v IIdContext)

func (*Create_column_master_keyContext) SetKey_path

func (s *Create_column_master_keyContext) SetKey_path(v antlr.Token)

func (*Create_column_master_keyContext) SetKey_store_provider_name

func (s *Create_column_master_keyContext) SetKey_store_provider_name(v antlr.Token)

func (*Create_column_master_keyContext) ToStringTree

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

func (*Create_column_master_keyContext) WITH

type Create_contractContext

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

func NewCreate_contractContext

func NewCreate_contractContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_contractContext

func NewEmptyCreate_contractContext

func NewEmptyCreate_contractContext() *Create_contractContext

func (*Create_contractContext) ANY

func (*Create_contractContext) AUTHORIZATION

func (s *Create_contractContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_contractContext) AllANY

func (*Create_contractContext) AllBY

func (*Create_contractContext) AllCOMMA

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

func (*Create_contractContext) AllDEFAULT

func (s *Create_contractContext) AllDEFAULT() []antlr.TerminalNode

func (*Create_contractContext) AllINITIATOR

func (s *Create_contractContext) AllINITIATOR() []antlr.TerminalNode

func (*Create_contractContext) AllId

func (s *Create_contractContext) AllId() []IIdContext

func (*Create_contractContext) AllSENT

func (s *Create_contractContext) AllSENT() []antlr.TerminalNode

func (*Create_contractContext) AllTARGET

func (s *Create_contractContext) AllTARGET() []antlr.TerminalNode

func (*Create_contractContext) BY

func (*Create_contractContext) COMMA

func (*Create_contractContext) CONTRACT

func (*Create_contractContext) CREATE

func (*Create_contractContext) Contract_name

func (s *Create_contractContext) Contract_name() IContract_nameContext

func (*Create_contractContext) DEFAULT

func (*Create_contractContext) EnterRule

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

func (*Create_contractContext) ExitRule

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

func (*Create_contractContext) GetMessage_type_name

func (s *Create_contractContext) GetMessage_type_name() IIdContext

func (*Create_contractContext) GetOwner_name

func (s *Create_contractContext) GetOwner_name() IIdContext

func (*Create_contractContext) GetParser

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

func (*Create_contractContext) GetRuleContext

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

func (*Create_contractContext) INITIATOR

func (s *Create_contractContext) INITIATOR(i int) antlr.TerminalNode

func (*Create_contractContext) Id

func (*Create_contractContext) IsCreate_contractContext

func (*Create_contractContext) IsCreate_contractContext()

func (*Create_contractContext) LR_BRACKET

func (s *Create_contractContext) LR_BRACKET() antlr.TerminalNode

func (*Create_contractContext) RR_BRACKET

func (s *Create_contractContext) RR_BRACKET() antlr.TerminalNode

func (*Create_contractContext) SENT

func (*Create_contractContext) SetMessage_type_name

func (s *Create_contractContext) SetMessage_type_name(v IIdContext)

func (*Create_contractContext) SetOwner_name

func (s *Create_contractContext) SetOwner_name(v IIdContext)

func (*Create_contractContext) TARGET

func (*Create_contractContext) ToStringTree

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

type Create_credentialContext

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

func NewCreate_credentialContext

func NewCreate_credentialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_credentialContext

func NewEmptyCreate_credentialContext

func NewEmptyCreate_credentialContext() *Create_credentialContext

func (*Create_credentialContext) AllEQUAL

func (*Create_credentialContext) AllId

func (s *Create_credentialContext) AllId() []IIdContext

func (*Create_credentialContext) AllSTRING

func (s *Create_credentialContext) AllSTRING() []antlr.TerminalNode

func (*Create_credentialContext) COMMA

func (*Create_credentialContext) CREATE

func (*Create_credentialContext) CREDENTIAL

func (*Create_credentialContext) CRYPTOGRAPHIC

func (s *Create_credentialContext) CRYPTOGRAPHIC() antlr.TerminalNode

func (*Create_credentialContext) EQUAL

func (*Create_credentialContext) EnterRule

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

func (*Create_credentialContext) ExitRule

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

func (*Create_credentialContext) FOR

func (*Create_credentialContext) GetCredential_name

func (s *Create_credentialContext) GetCredential_name() IIdContext

func (*Create_credentialContext) GetCryptographic_provider_name

func (s *Create_credentialContext) GetCryptographic_provider_name() IIdContext

func (*Create_credentialContext) GetIdentity_name

func (s *Create_credentialContext) GetIdentity_name() antlr.Token

func (*Create_credentialContext) GetParser

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

func (*Create_credentialContext) GetRuleContext

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

func (*Create_credentialContext) GetSecret

func (s *Create_credentialContext) GetSecret() antlr.Token

func (*Create_credentialContext) IDENTITY

func (*Create_credentialContext) Id

func (*Create_credentialContext) IsCreate_credentialContext

func (*Create_credentialContext) IsCreate_credentialContext()

func (*Create_credentialContext) PROVIDER

func (*Create_credentialContext) SECRET

func (*Create_credentialContext) STRING

func (*Create_credentialContext) SetCredential_name

func (s *Create_credentialContext) SetCredential_name(v IIdContext)

func (*Create_credentialContext) SetCryptographic_provider_name

func (s *Create_credentialContext) SetCryptographic_provider_name(v IIdContext)

func (*Create_credentialContext) SetIdentity_name

func (s *Create_credentialContext) SetIdentity_name(v antlr.Token)

func (*Create_credentialContext) SetSecret

func (s *Create_credentialContext) SetSecret(v antlr.Token)

func (*Create_credentialContext) ToStringTree

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

func (*Create_credentialContext) WITH

type Create_cryptographic_providerContext

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

func NewCreate_cryptographic_providerContext

func NewCreate_cryptographic_providerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_cryptographic_providerContext

func NewEmptyCreate_cryptographic_providerContext

func NewEmptyCreate_cryptographic_providerContext() *Create_cryptographic_providerContext

func (*Create_cryptographic_providerContext) CREATE

func (*Create_cryptographic_providerContext) CRYPTOGRAPHIC

func (*Create_cryptographic_providerContext) EQUAL

func (*Create_cryptographic_providerContext) EnterRule

func (*Create_cryptographic_providerContext) ExitRule

func (*Create_cryptographic_providerContext) FILE

func (*Create_cryptographic_providerContext) FROM

func (*Create_cryptographic_providerContext) GetParser

func (*Create_cryptographic_providerContext) GetPath_of_DLL

func (s *Create_cryptographic_providerContext) GetPath_of_DLL() antlr.Token

func (*Create_cryptographic_providerContext) GetProvider_name

func (s *Create_cryptographic_providerContext) GetProvider_name() IIdContext

func (*Create_cryptographic_providerContext) GetRuleContext

func (*Create_cryptographic_providerContext) Id

func (*Create_cryptographic_providerContext) IsCreate_cryptographic_providerContext

func (*Create_cryptographic_providerContext) IsCreate_cryptographic_providerContext()

func (*Create_cryptographic_providerContext) PROVIDER

func (*Create_cryptographic_providerContext) STRING

func (*Create_cryptographic_providerContext) SetPath_of_DLL

func (s *Create_cryptographic_providerContext) SetPath_of_DLL(v antlr.Token)

func (*Create_cryptographic_providerContext) SetProvider_name

func (s *Create_cryptographic_providerContext) SetProvider_name(v IIdContext)

func (*Create_cryptographic_providerContext) ToStringTree

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

type Create_databaseContext

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

func NewCreate_databaseContext

func NewCreate_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_databaseContext

func NewEmptyCreate_databaseContext

func NewEmptyCreate_databaseContext() *Create_databaseContext

func (*Create_databaseContext) AllCOMMA

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

func (*Create_databaseContext) AllCreate_database_option

func (s *Create_databaseContext) AllCreate_database_option() []ICreate_database_optionContext

func (*Create_databaseContext) AllDatabase_file_spec

func (s *Create_databaseContext) AllDatabase_file_spec() []IDatabase_file_specContext

func (*Create_databaseContext) AllId

func (s *Create_databaseContext) AllId() []IIdContext

func (*Create_databaseContext) AllON

func (*Create_databaseContext) COLLATE

func (*Create_databaseContext) COMMA

func (*Create_databaseContext) CONTAINMENT

func (s *Create_databaseContext) CONTAINMENT() antlr.TerminalNode

func (*Create_databaseContext) CREATE

func (*Create_databaseContext) Create_database_option

func (s *Create_databaseContext) Create_database_option(i int) ICreate_database_optionContext

func (*Create_databaseContext) DATABASE

func (*Create_databaseContext) Database_file_spec

func (s *Create_databaseContext) Database_file_spec(i int) IDatabase_file_specContext

func (*Create_databaseContext) EQUAL

func (*Create_databaseContext) EnterRule

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

func (*Create_databaseContext) ExitRule

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

func (*Create_databaseContext) GetCollation_name

func (s *Create_databaseContext) GetCollation_name() IIdContext

func (*Create_databaseContext) GetDatabase

func (s *Create_databaseContext) GetDatabase() IIdContext

func (*Create_databaseContext) GetParser

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

func (*Create_databaseContext) GetRuleContext

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

func (*Create_databaseContext) Id

func (*Create_databaseContext) IsCreate_databaseContext

func (*Create_databaseContext) IsCreate_databaseContext()

func (*Create_databaseContext) LOG

func (*Create_databaseContext) NONE

func (*Create_databaseContext) ON

func (*Create_databaseContext) PARTIAL

func (*Create_databaseContext) PRIMARY

func (*Create_databaseContext) SetCollation_name

func (s *Create_databaseContext) SetCollation_name(v IIdContext)

func (*Create_databaseContext) SetDatabase

func (s *Create_databaseContext) SetDatabase(v IIdContext)

func (*Create_databaseContext) ToStringTree

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

func (*Create_databaseContext) WITH

type Create_database_optionContext

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

func NewCreate_database_optionContext

func NewCreate_database_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_database_optionContext

func NewEmptyCreate_database_optionContext

func NewEmptyCreate_database_optionContext() *Create_database_optionContext

func (*Create_database_optionContext) AllCOMMA

func (*Create_database_optionContext) AllDatabase_filestream_option

func (s *Create_database_optionContext) AllDatabase_filestream_option() []IDatabase_filestream_optionContext

func (*Create_database_optionContext) COMMA

func (*Create_database_optionContext) DB_CHAINING

func (*Create_database_optionContext) DECIMAL

func (*Create_database_optionContext) DEFAULT_FULLTEXT_LANGUAGE

func (s *Create_database_optionContext) DEFAULT_FULLTEXT_LANGUAGE() antlr.TerminalNode

func (*Create_database_optionContext) DEFAULT_LANGUAGE

func (s *Create_database_optionContext) DEFAULT_LANGUAGE() antlr.TerminalNode

func (*Create_database_optionContext) Database_filestream_option

func (s *Create_database_optionContext) Database_filestream_option(i int) IDatabase_filestream_optionContext

func (*Create_database_optionContext) EQUAL

func (*Create_database_optionContext) EnterRule

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

func (*Create_database_optionContext) ExitRule

func (*Create_database_optionContext) FILESTREAM

func (*Create_database_optionContext) GetParser

func (*Create_database_optionContext) GetRuleContext

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

func (*Create_database_optionContext) Id

func (*Create_database_optionContext) IsCreate_database_optionContext

func (*Create_database_optionContext) IsCreate_database_optionContext()

func (*Create_database_optionContext) NESTED_TRIGGERS

func (s *Create_database_optionContext) NESTED_TRIGGERS() antlr.TerminalNode

func (*Create_database_optionContext) OFF

func (*Create_database_optionContext) ON

func (*Create_database_optionContext) STRING

func (*Create_database_optionContext) TRANSFORM_NOISE_WORDS

func (s *Create_database_optionContext) TRANSFORM_NOISE_WORDS() antlr.TerminalNode

func (*Create_database_optionContext) TRUSTWORTHY

func (*Create_database_optionContext) TWO_DIGIT_YEAR_CUTOFF

func (s *Create_database_optionContext) TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode

func (*Create_database_optionContext) ToStringTree

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

type Create_db_roleContext

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

func NewCreate_db_roleContext

func NewCreate_db_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_db_roleContext

func NewEmptyCreate_db_roleContext

func NewEmptyCreate_db_roleContext() *Create_db_roleContext

func (*Create_db_roleContext) AUTHORIZATION

func (s *Create_db_roleContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_db_roleContext) AllId

func (s *Create_db_roleContext) AllId() []IIdContext

func (*Create_db_roleContext) CREATE

func (*Create_db_roleContext) EnterRule

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

func (*Create_db_roleContext) ExitRule

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

func (*Create_db_roleContext) GetOwner_name

func (s *Create_db_roleContext) GetOwner_name() IIdContext

func (*Create_db_roleContext) GetParser

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

func (*Create_db_roleContext) GetRole_name

func (s *Create_db_roleContext) GetRole_name() IIdContext

func (*Create_db_roleContext) GetRuleContext

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

func (*Create_db_roleContext) Id

func (*Create_db_roleContext) IsCreate_db_roleContext

func (*Create_db_roleContext) IsCreate_db_roleContext()

func (*Create_db_roleContext) ROLE

func (*Create_db_roleContext) SetOwner_name

func (s *Create_db_roleContext) SetOwner_name(v IIdContext)

func (*Create_db_roleContext) SetRole_name

func (s *Create_db_roleContext) SetRole_name(v IIdContext)

func (*Create_db_roleContext) ToStringTree

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

type Create_event_notificationContext

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

func NewCreate_event_notificationContext

func NewCreate_event_notificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_event_notificationContext

func NewEmptyCreate_event_notificationContext

func NewEmptyCreate_event_notificationContext() *Create_event_notificationContext

func (*Create_event_notificationContext) AllCOMMA

func (*Create_event_notificationContext) AllId

func (*Create_event_notificationContext) AllSTRING

func (*Create_event_notificationContext) COMMA

func (*Create_event_notificationContext) CREATE

func (*Create_event_notificationContext) DATABASE

func (*Create_event_notificationContext) EVENT

func (*Create_event_notificationContext) EnterRule

func (*Create_event_notificationContext) ExitRule

func (*Create_event_notificationContext) FAN_IN

func (*Create_event_notificationContext) FOR

func (*Create_event_notificationContext) GetBroker_service

func (s *Create_event_notificationContext) GetBroker_service() antlr.Token

func (*Create_event_notificationContext) GetBroker_service_specifier_or_current_database

func (s *Create_event_notificationContext) GetBroker_service_specifier_or_current_database() antlr.Token

func (*Create_event_notificationContext) GetEvent_notification_name

func (s *Create_event_notificationContext) GetEvent_notification_name() IIdContext

func (*Create_event_notificationContext) GetEvent_type_or_group

func (s *Create_event_notificationContext) GetEvent_type_or_group() IIdContext

func (*Create_event_notificationContext) GetParser

func (*Create_event_notificationContext) GetQueue_name

func (s *Create_event_notificationContext) GetQueue_name() IIdContext

func (*Create_event_notificationContext) GetRuleContext

func (*Create_event_notificationContext) Id

func (*Create_event_notificationContext) IsCreate_event_notificationContext

func (*Create_event_notificationContext) IsCreate_event_notificationContext()

func (*Create_event_notificationContext) NOTIFICATION

func (*Create_event_notificationContext) ON

func (*Create_event_notificationContext) QUEUE

func (*Create_event_notificationContext) SERVER

func (*Create_event_notificationContext) SERVICE

func (*Create_event_notificationContext) STRING

func (*Create_event_notificationContext) SetBroker_service

func (s *Create_event_notificationContext) SetBroker_service(v antlr.Token)

func (*Create_event_notificationContext) SetBroker_service_specifier_or_current_database

func (s *Create_event_notificationContext) SetBroker_service_specifier_or_current_database(v antlr.Token)

func (*Create_event_notificationContext) SetEvent_notification_name

func (s *Create_event_notificationContext) SetEvent_notification_name(v IIdContext)

func (*Create_event_notificationContext) SetEvent_type_or_group

func (s *Create_event_notificationContext) SetEvent_type_or_group(v IIdContext)

func (*Create_event_notificationContext) SetQueue_name

func (s *Create_event_notificationContext) SetQueue_name(v IIdContext)

func (*Create_event_notificationContext) TO

func (*Create_event_notificationContext) ToStringTree

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

func (*Create_event_notificationContext) WITH

type Create_external_libraryContext

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

func NewCreate_external_libraryContext

func NewCreate_external_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_external_libraryContext

func NewEmptyCreate_external_libraryContext

func NewEmptyCreate_external_libraryContext() *Create_external_libraryContext

func (*Create_external_libraryContext) AUTHORIZATION

func (*Create_external_libraryContext) AllCOMMA

func (*Create_external_libraryContext) AllDATA_SOURCE

func (s *Create_external_libraryContext) AllDATA_SOURCE() []antlr.TerminalNode

func (*Create_external_libraryContext) AllEQUAL

func (*Create_external_libraryContext) AllId

func (*Create_external_libraryContext) AllLANGUAGE

func (*Create_external_libraryContext) AllPYTHON

func (*Create_external_libraryContext) AllR

func (*Create_external_libraryContext) AllRR_BRACKET

func (s *Create_external_libraryContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Create_external_libraryContext) BINARY

func (*Create_external_libraryContext) COMMA

func (*Create_external_libraryContext) CONTENT

func (*Create_external_libraryContext) CREATE

func (*Create_external_libraryContext) DATA_SOURCE

func (*Create_external_libraryContext) EQUAL

func (*Create_external_libraryContext) EXTERNAL

func (*Create_external_libraryContext) EnterRule

func (*Create_external_libraryContext) ExitRule

func (*Create_external_libraryContext) FROM

func (*Create_external_libraryContext) GetClient_library

func (s *Create_external_libraryContext) GetClient_library() antlr.Token

func (*Create_external_libraryContext) GetExternal_data_source_name

func (s *Create_external_libraryContext) GetExternal_data_source_name() IIdContext

func (*Create_external_libraryContext) GetLibrary_name

func (s *Create_external_libraryContext) GetLibrary_name() IIdContext

func (*Create_external_libraryContext) GetOwner_name

func (s *Create_external_libraryContext) GetOwner_name() IIdContext

func (*Create_external_libraryContext) GetParser

func (*Create_external_libraryContext) GetRuleContext

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

func (*Create_external_libraryContext) Id

func (*Create_external_libraryContext) IsCreate_external_libraryContext

func (*Create_external_libraryContext) IsCreate_external_libraryContext()

func (*Create_external_libraryContext) LANGUAGE

func (*Create_external_libraryContext) LIBRARY

func (*Create_external_libraryContext) LINUX

func (*Create_external_libraryContext) LR_BRACKET

func (*Create_external_libraryContext) NONE

func (*Create_external_libraryContext) PLATFORM

func (*Create_external_libraryContext) PYTHON

func (*Create_external_libraryContext) R

func (*Create_external_libraryContext) RR_BRACKET

func (*Create_external_libraryContext) STRING

func (*Create_external_libraryContext) SetClient_library

func (s *Create_external_libraryContext) SetClient_library(v antlr.Token)

func (*Create_external_libraryContext) SetExternal_data_source_name

func (s *Create_external_libraryContext) SetExternal_data_source_name(v IIdContext)

func (*Create_external_libraryContext) SetLibrary_name

func (s *Create_external_libraryContext) SetLibrary_name(v IIdContext)

func (*Create_external_libraryContext) SetOwner_name

func (s *Create_external_libraryContext) SetOwner_name(v IIdContext)

func (*Create_external_libraryContext) ToStringTree

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

func (*Create_external_libraryContext) WINDOWS

func (*Create_external_libraryContext) WITH

type Create_external_resource_poolContext

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

func NewCreate_external_resource_poolContext

func NewCreate_external_resource_poolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_external_resource_poolContext

func NewEmptyCreate_external_resource_poolContext

func NewEmptyCreate_external_resource_poolContext() *Create_external_resource_poolContext

func (*Create_external_resource_poolContext) AFFINITY

func (*Create_external_resource_poolContext) AUTO

func (*Create_external_resource_poolContext) AllCOMMA

func (*Create_external_resource_poolContext) AllDECIMAL

func (*Create_external_resource_poolContext) AllEQUAL

func (*Create_external_resource_poolContext) AllTO

func (*Create_external_resource_poolContext) COMMA

func (*Create_external_resource_poolContext) CPU

func (*Create_external_resource_poolContext) CREATE

func (*Create_external_resource_poolContext) DECIMAL

func (*Create_external_resource_poolContext) EQUAL

func (*Create_external_resource_poolContext) EXTERNAL

func (*Create_external_resource_poolContext) EnterRule

func (*Create_external_resource_poolContext) ExitRule

func (*Create_external_resource_poolContext) GetMax_cpu_percent

func (s *Create_external_resource_poolContext) GetMax_cpu_percent() antlr.Token

func (*Create_external_resource_poolContext) GetMax_memory_percent

func (s *Create_external_resource_poolContext) GetMax_memory_percent() antlr.Token

func (*Create_external_resource_poolContext) GetMax_processes

func (s *Create_external_resource_poolContext) GetMax_processes() antlr.Token

func (*Create_external_resource_poolContext) GetParser

func (*Create_external_resource_poolContext) GetPool_name

func (*Create_external_resource_poolContext) GetRuleContext

func (*Create_external_resource_poolContext) Id

func (*Create_external_resource_poolContext) IsCreate_external_resource_poolContext

func (*Create_external_resource_poolContext) IsCreate_external_resource_poolContext()

func (*Create_external_resource_poolContext) LR_BRACKET

func (*Create_external_resource_poolContext) MAX_CPU_PERCENT

func (*Create_external_resource_poolContext) MAX_MEMORY_PERCENT

func (*Create_external_resource_poolContext) MAX_PROCESSES

func (*Create_external_resource_poolContext) NUMANODE

func (*Create_external_resource_poolContext) POOL

func (*Create_external_resource_poolContext) RESOURCE

func (*Create_external_resource_poolContext) RR_BRACKET

func (*Create_external_resource_poolContext) SetMax_cpu_percent

func (s *Create_external_resource_poolContext) SetMax_cpu_percent(v antlr.Token)

func (*Create_external_resource_poolContext) SetMax_memory_percent

func (s *Create_external_resource_poolContext) SetMax_memory_percent(v antlr.Token)

func (*Create_external_resource_poolContext) SetMax_processes

func (s *Create_external_resource_poolContext) SetMax_processes(v antlr.Token)

func (*Create_external_resource_poolContext) SetPool_name

func (*Create_external_resource_poolContext) TO

func (*Create_external_resource_poolContext) ToStringTree

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

func (*Create_external_resource_poolContext) WITH

type Create_fulltext_catalogContext

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

func NewCreate_fulltext_catalogContext

func NewCreate_fulltext_catalogContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_fulltext_catalogContext

func NewEmptyCreate_fulltext_catalogContext

func NewEmptyCreate_fulltext_catalogContext() *Create_fulltext_catalogContext

func (*Create_fulltext_catalogContext) ACCENT_SENSITIVITY

func (s *Create_fulltext_catalogContext) ACCENT_SENSITIVITY() antlr.TerminalNode

func (*Create_fulltext_catalogContext) AS

func (*Create_fulltext_catalogContext) AUTHORIZATION

func (*Create_fulltext_catalogContext) AllId

func (*Create_fulltext_catalogContext) AllON

func (*Create_fulltext_catalogContext) CATALOG

func (*Create_fulltext_catalogContext) CREATE

func (*Create_fulltext_catalogContext) DEFAULT

func (*Create_fulltext_catalogContext) EQUAL

func (*Create_fulltext_catalogContext) EnterRule

func (*Create_fulltext_catalogContext) ExitRule

func (*Create_fulltext_catalogContext) FILEGROUP

func (*Create_fulltext_catalogContext) FULLTEXT

func (*Create_fulltext_catalogContext) GetCatalog_name

func (s *Create_fulltext_catalogContext) GetCatalog_name() IIdContext

func (*Create_fulltext_catalogContext) GetFilegroup

func (s *Create_fulltext_catalogContext) GetFilegroup() IIdContext

func (*Create_fulltext_catalogContext) GetOwner_name

func (s *Create_fulltext_catalogContext) GetOwner_name() IIdContext

func (*Create_fulltext_catalogContext) GetParser

func (*Create_fulltext_catalogContext) GetRootpath

func (s *Create_fulltext_catalogContext) GetRootpath() antlr.Token

func (*Create_fulltext_catalogContext) GetRuleContext

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

func (*Create_fulltext_catalogContext) IN

func (*Create_fulltext_catalogContext) Id

func (*Create_fulltext_catalogContext) IsCreate_fulltext_catalogContext

func (*Create_fulltext_catalogContext) IsCreate_fulltext_catalogContext()

func (*Create_fulltext_catalogContext) OFF

func (*Create_fulltext_catalogContext) ON

func (*Create_fulltext_catalogContext) PATH

func (*Create_fulltext_catalogContext) STRING

func (*Create_fulltext_catalogContext) SetCatalog_name

func (s *Create_fulltext_catalogContext) SetCatalog_name(v IIdContext)

func (*Create_fulltext_catalogContext) SetFilegroup

func (s *Create_fulltext_catalogContext) SetFilegroup(v IIdContext)

func (*Create_fulltext_catalogContext) SetOwner_name

func (s *Create_fulltext_catalogContext) SetOwner_name(v IIdContext)

func (*Create_fulltext_catalogContext) SetRootpath

func (s *Create_fulltext_catalogContext) SetRootpath(v antlr.Token)

func (*Create_fulltext_catalogContext) ToStringTree

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

func (*Create_fulltext_catalogContext) WITH

type Create_fulltext_stoplistContext

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

func NewCreate_fulltext_stoplistContext

func NewCreate_fulltext_stoplistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_fulltext_stoplistContext

func NewEmptyCreate_fulltext_stoplistContext

func NewEmptyCreate_fulltext_stoplistContext() *Create_fulltext_stoplistContext

func (*Create_fulltext_stoplistContext) AUTHORIZATION

func (*Create_fulltext_stoplistContext) AllId

func (*Create_fulltext_stoplistContext) AllSTOPLIST

func (*Create_fulltext_stoplistContext) CREATE

func (*Create_fulltext_stoplistContext) DOT

func (*Create_fulltext_stoplistContext) EnterRule

func (*Create_fulltext_stoplistContext) ExitRule

func (*Create_fulltext_stoplistContext) FROM

func (*Create_fulltext_stoplistContext) FULLTEXT

func (*Create_fulltext_stoplistContext) GetDatabase_name

func (s *Create_fulltext_stoplistContext) GetDatabase_name() IIdContext

func (*Create_fulltext_stoplistContext) GetOwner_name

func (s *Create_fulltext_stoplistContext) GetOwner_name() IIdContext

func (*Create_fulltext_stoplistContext) GetParser

func (*Create_fulltext_stoplistContext) GetRuleContext

func (*Create_fulltext_stoplistContext) GetSource_stoplist_name

func (s *Create_fulltext_stoplistContext) GetSource_stoplist_name() IIdContext

func (*Create_fulltext_stoplistContext) GetStoplist_name

func (s *Create_fulltext_stoplistContext) GetStoplist_name() IIdContext

func (*Create_fulltext_stoplistContext) Id

func (*Create_fulltext_stoplistContext) IsCreate_fulltext_stoplistContext

func (*Create_fulltext_stoplistContext) IsCreate_fulltext_stoplistContext()

func (*Create_fulltext_stoplistContext) STOPLIST

func (*Create_fulltext_stoplistContext) SYSTEM

func (*Create_fulltext_stoplistContext) SetDatabase_name

func (s *Create_fulltext_stoplistContext) SetDatabase_name(v IIdContext)

func (*Create_fulltext_stoplistContext) SetOwner_name

func (s *Create_fulltext_stoplistContext) SetOwner_name(v IIdContext)

func (*Create_fulltext_stoplistContext) SetSource_stoplist_name

func (s *Create_fulltext_stoplistContext) SetSource_stoplist_name(v IIdContext)

func (*Create_fulltext_stoplistContext) SetStoplist_name

func (s *Create_fulltext_stoplistContext) SetStoplist_name(v IIdContext)

func (*Create_fulltext_stoplistContext) ToStringTree

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

type Create_indexContext

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

func NewCreate_indexContext

func NewCreate_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_indexContext

func NewEmptyCreate_indexContext

func NewEmptyCreate_indexContext() *Create_indexContext

func (*Create_indexContext) AllId

func (s *Create_indexContext) AllId() []IIdContext

func (*Create_indexContext) AllLR_BRACKET

func (s *Create_indexContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Create_indexContext) AllON

func (s *Create_indexContext) AllON() []antlr.TerminalNode

func (*Create_indexContext) AllRR_BRACKET

func (s *Create_indexContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Create_indexContext) CREATE

func (*Create_indexContext) Clustered

func (s *Create_indexContext) Clustered() IClusteredContext

func (*Create_indexContext) Column_name_list

func (s *Create_indexContext) Column_name_list() IColumn_name_listContext

func (*Create_indexContext) Column_name_list_with_order

func (s *Create_indexContext) Column_name_list_with_order() IColumn_name_list_with_orderContext

func (*Create_indexContext) EnterRule

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

func (*Create_indexContext) ExitRule

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

func (*Create_indexContext) GetParser

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

func (*Create_indexContext) GetRuleContext

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

func (*Create_indexContext) GetWhere

func (*Create_indexContext) INCLUDE

func (s *Create_indexContext) INCLUDE() antlr.TerminalNode

func (*Create_indexContext) INDEX

func (*Create_indexContext) Id

func (*Create_indexContext) Index_options

func (s *Create_indexContext) Index_options() IIndex_optionsContext

func (*Create_indexContext) IsCreate_indexContext

func (*Create_indexContext) IsCreate_indexContext()

func (*Create_indexContext) LR_BRACKET

func (s *Create_indexContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Create_indexContext) ON

func (*Create_indexContext) RR_BRACKET

func (s *Create_indexContext) RR_BRACKET(i int) antlr.TerminalNode

func (*Create_indexContext) SEMI

func (*Create_indexContext) Search_condition

func (s *Create_indexContext) Search_condition() ISearch_conditionContext

func (*Create_indexContext) SetWhere

func (*Create_indexContext) Table_name_with_hint

func (s *Create_indexContext) Table_name_with_hint() ITable_name_with_hintContext

func (*Create_indexContext) ToStringTree

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

func (*Create_indexContext) UNIQUE

func (*Create_indexContext) WHERE

type Create_keyContext

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

func NewCreate_keyContext

func NewCreate_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_keyContext

func NewEmptyCreate_keyContext

func NewEmptyCreate_keyContext() *Create_keyContext

func (*Create_keyContext) AUTHORIZATION

func (s *Create_keyContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_keyContext) AllBY

func (s *Create_keyContext) AllBY() []antlr.TerminalNode

func (*Create_keyContext) AllCOMMA

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

func (*Create_keyContext) AllENCRYPTION

func (s *Create_keyContext) AllENCRYPTION() []antlr.TerminalNode

func (*Create_keyContext) AllEncryption_mechanism

func (s *Create_keyContext) AllEncryption_mechanism() []IEncryption_mechanismContext

func (*Create_keyContext) AllId

func (s *Create_keyContext) AllId() []IIdContext

func (*Create_keyContext) AllKey_options

func (s *Create_keyContext) AllKey_options() []IKey_optionsContext

func (*Create_keyContext) BY

func (*Create_keyContext) COMMA

func (*Create_keyContext) CREATE

func (s *Create_keyContext) CREATE() antlr.TerminalNode

func (*Create_keyContext) ENCRYPTION

func (s *Create_keyContext) ENCRYPTION(i int) antlr.TerminalNode

func (*Create_keyContext) EQUAL

func (*Create_keyContext) Encryption_mechanism

func (s *Create_keyContext) Encryption_mechanism(i int) IEncryption_mechanismContext

func (*Create_keyContext) EnterRule

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

func (*Create_keyContext) ExitRule

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

func (*Create_keyContext) FROM

func (*Create_keyContext) GetKey_name

func (s *Create_keyContext) GetKey_name() IIdContext

func (*Create_keyContext) GetParser

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

func (*Create_keyContext) GetPassword

func (s *Create_keyContext) GetPassword() antlr.Token

func (*Create_keyContext) GetProvider_name

func (s *Create_keyContext) GetProvider_name() IIdContext

func (*Create_keyContext) GetRuleContext

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

func (*Create_keyContext) GetUser_name

func (s *Create_keyContext) GetUser_name() IIdContext

func (*Create_keyContext) Id

func (s *Create_keyContext) Id(i int) IIdContext

func (*Create_keyContext) IsCreate_keyContext

func (*Create_keyContext) IsCreate_keyContext()

func (*Create_keyContext) KEY

func (*Create_keyContext) Key_options

func (s *Create_keyContext) Key_options(i int) IKey_optionsContext

func (*Create_keyContext) MASTER

func (s *Create_keyContext) MASTER() antlr.TerminalNode

func (*Create_keyContext) PASSWORD

func (s *Create_keyContext) PASSWORD() antlr.TerminalNode

func (*Create_keyContext) PROVIDER

func (s *Create_keyContext) PROVIDER() antlr.TerminalNode

func (*Create_keyContext) STRING

func (s *Create_keyContext) STRING() antlr.TerminalNode

func (*Create_keyContext) SYMMETRIC

func (s *Create_keyContext) SYMMETRIC() antlr.TerminalNode

func (*Create_keyContext) SetKey_name

func (s *Create_keyContext) SetKey_name(v IIdContext)

func (*Create_keyContext) SetPassword

func (s *Create_keyContext) SetPassword(v antlr.Token)

func (*Create_keyContext) SetProvider_name

func (s *Create_keyContext) SetProvider_name(v IIdContext)

func (*Create_keyContext) SetUser_name

func (s *Create_keyContext) SetUser_name(v IIdContext)

func (*Create_keyContext) ToStringTree

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

func (*Create_keyContext) WITH

type Create_login_azure_sqlContext

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

func NewCreate_login_azure_sqlContext

func NewCreate_login_azure_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_login_azure_sqlContext

func NewEmptyCreate_login_azure_sqlContext

func NewEmptyCreate_login_azure_sqlContext() *Create_login_azure_sqlContext

func (*Create_login_azure_sqlContext) AllEQUAL

func (*Create_login_azure_sqlContext) BINARY

func (*Create_login_azure_sqlContext) CREATE

func (*Create_login_azure_sqlContext) EQUAL

func (*Create_login_azure_sqlContext) EnterRule

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

func (*Create_login_azure_sqlContext) ExitRule

func (*Create_login_azure_sqlContext) GetLogin_name

func (s *Create_login_azure_sqlContext) GetLogin_name() IIdContext

func (*Create_login_azure_sqlContext) GetParser

func (*Create_login_azure_sqlContext) GetRuleContext

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

func (*Create_login_azure_sqlContext) GetSid

func (*Create_login_azure_sqlContext) Id

func (*Create_login_azure_sqlContext) IsCreate_login_azure_sqlContext

func (*Create_login_azure_sqlContext) IsCreate_login_azure_sqlContext()

func (*Create_login_azure_sqlContext) LOGIN

func (*Create_login_azure_sqlContext) PASSWORD

func (*Create_login_azure_sqlContext) SID

func (*Create_login_azure_sqlContext) STRING

func (*Create_login_azure_sqlContext) SetLogin_name

func (s *Create_login_azure_sqlContext) SetLogin_name(v IIdContext)

func (*Create_login_azure_sqlContext) SetSid

func (*Create_login_azure_sqlContext) ToStringTree

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

func (*Create_login_azure_sqlContext) WITH

type Create_login_pdwContext

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

func NewCreate_login_pdwContext

func NewCreate_login_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_login_pdwContext

func NewEmptyCreate_login_pdwContext

func NewEmptyCreate_login_pdwContext() *Create_login_pdwContext

func (*Create_login_pdwContext) AllEQUAL

func (s *Create_login_pdwContext) AllEQUAL() []antlr.TerminalNode

func (*Create_login_pdwContext) CHECK_POLICY

func (s *Create_login_pdwContext) CHECK_POLICY() antlr.TerminalNode

func (*Create_login_pdwContext) CREATE

func (*Create_login_pdwContext) EQUAL

func (*Create_login_pdwContext) EnterRule

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

func (*Create_login_pdwContext) ExitRule

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

func (*Create_login_pdwContext) FROM

func (*Create_login_pdwContext) GetLoginName

func (s *Create_login_pdwContext) GetLoginName() IIdContext

func (*Create_login_pdwContext) GetParser

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

func (*Create_login_pdwContext) GetPassword

func (s *Create_login_pdwContext) GetPassword() antlr.Token

func (*Create_login_pdwContext) GetRuleContext

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

func (*Create_login_pdwContext) Id

func (*Create_login_pdwContext) IsCreate_login_pdwContext

func (*Create_login_pdwContext) IsCreate_login_pdwContext()

func (*Create_login_pdwContext) LOGIN

func (*Create_login_pdwContext) MUST_CHANGE

func (s *Create_login_pdwContext) MUST_CHANGE() antlr.TerminalNode

func (*Create_login_pdwContext) OFF

func (*Create_login_pdwContext) ON

func (*Create_login_pdwContext) PASSWORD

func (*Create_login_pdwContext) STRING

func (*Create_login_pdwContext) SetLoginName

func (s *Create_login_pdwContext) SetLoginName(v IIdContext)

func (*Create_login_pdwContext) SetPassword

func (s *Create_login_pdwContext) SetPassword(v antlr.Token)

func (*Create_login_pdwContext) ToStringTree

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

func (*Create_login_pdwContext) WINDOWS

func (*Create_login_pdwContext) WITH

type Create_login_sql_serverContext

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

func NewCreate_login_sql_serverContext

func NewCreate_login_sql_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_login_sql_serverContext

func NewEmptyCreate_login_sql_serverContext

func NewEmptyCreate_login_sql_serverContext() *Create_login_sql_serverContext

func (*Create_login_sql_serverContext) ASYMMETRIC

func (*Create_login_sql_serverContext) AllBINARY

func (*Create_login_sql_serverContext) AllCOMMA

func (*Create_login_sql_serverContext) AllEQUAL

func (*Create_login_sql_serverContext) AllId

func (*Create_login_sql_serverContext) AllMUST_CHANGE

func (s *Create_login_sql_serverContext) AllMUST_CHANGE() []antlr.TerminalNode

func (*Create_login_sql_serverContext) AllOFF

func (*Create_login_sql_serverContext) AllON

func (*Create_login_sql_serverContext) AllUNLOCK

func (*Create_login_sql_serverContext) BINARY

func (*Create_login_sql_serverContext) CERTIFICATE

func (*Create_login_sql_serverContext) CHECK_EXPIRATION

func (s *Create_login_sql_serverContext) CHECK_EXPIRATION() antlr.TerminalNode

func (*Create_login_sql_serverContext) CHECK_POLICY

func (*Create_login_sql_serverContext) COMMA

func (*Create_login_sql_serverContext) CREATE

func (*Create_login_sql_serverContext) CREDENTIAL

func (*Create_login_sql_serverContext) DEFAULT_DATABASE

func (s *Create_login_sql_serverContext) DEFAULT_DATABASE() antlr.TerminalNode

func (*Create_login_sql_serverContext) DEFAULT_LANGUAGE

func (s *Create_login_sql_serverContext) DEFAULT_LANGUAGE() antlr.TerminalNode

func (*Create_login_sql_serverContext) EQUAL

func (*Create_login_sql_serverContext) EnterRule

func (*Create_login_sql_serverContext) ExitRule

func (*Create_login_sql_serverContext) FROM

func (*Create_login_sql_serverContext) GetAsym_key_name

func (s *Create_login_sql_serverContext) GetAsym_key_name() IIdContext

func (*Create_login_sql_serverContext) GetCertname

func (s *Create_login_sql_serverContext) GetCertname() IIdContext

func (*Create_login_sql_serverContext) GetCredential_name

func (s *Create_login_sql_serverContext) GetCredential_name() IIdContext

func (*Create_login_sql_serverContext) GetDefault_database

func (s *Create_login_sql_serverContext) GetDefault_database() IIdContext

func (*Create_login_sql_serverContext) GetDefault_laguage

func (s *Create_login_sql_serverContext) GetDefault_laguage() IIdContext

func (*Create_login_sql_serverContext) GetDefault_language

func (s *Create_login_sql_serverContext) GetDefault_language() antlr.Token

func (*Create_login_sql_serverContext) GetLogin_name

func (s *Create_login_sql_serverContext) GetLogin_name() IIdContext

func (*Create_login_sql_serverContext) GetParser

func (*Create_login_sql_serverContext) GetPassword

func (s *Create_login_sql_serverContext) GetPassword() antlr.Token

func (*Create_login_sql_serverContext) GetPassword_hash

func (s *Create_login_sql_serverContext) GetPassword_hash() antlr.Token

func (*Create_login_sql_serverContext) GetRuleContext

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

func (*Create_login_sql_serverContext) GetSid

func (*Create_login_sql_serverContext) HASHED

func (*Create_login_sql_serverContext) Id

func (*Create_login_sql_serverContext) IsCreate_login_sql_serverContext

func (*Create_login_sql_serverContext) IsCreate_login_sql_serverContext()

func (*Create_login_sql_serverContext) KEY

func (*Create_login_sql_serverContext) LOGIN

func (*Create_login_sql_serverContext) MUST_CHANGE

func (*Create_login_sql_serverContext) OFF

func (*Create_login_sql_serverContext) ON

func (*Create_login_sql_serverContext) PASSWORD

func (*Create_login_sql_serverContext) SID

func (*Create_login_sql_serverContext) STRING

func (*Create_login_sql_serverContext) SetAsym_key_name

func (s *Create_login_sql_serverContext) SetAsym_key_name(v IIdContext)

func (*Create_login_sql_serverContext) SetCertname

func (s *Create_login_sql_serverContext) SetCertname(v IIdContext)

func (*Create_login_sql_serverContext) SetCredential_name

func (s *Create_login_sql_serverContext) SetCredential_name(v IIdContext)

func (*Create_login_sql_serverContext) SetDefault_database

func (s *Create_login_sql_serverContext) SetDefault_database(v IIdContext)

func (*Create_login_sql_serverContext) SetDefault_laguage

func (s *Create_login_sql_serverContext) SetDefault_laguage(v IIdContext)

func (*Create_login_sql_serverContext) SetDefault_language

func (s *Create_login_sql_serverContext) SetDefault_language(v antlr.Token)

func (*Create_login_sql_serverContext) SetLogin_name

func (s *Create_login_sql_serverContext) SetLogin_name(v IIdContext)

func (*Create_login_sql_serverContext) SetPassword

func (s *Create_login_sql_serverContext) SetPassword(v antlr.Token)

func (*Create_login_sql_serverContext) SetPassword_hash

func (s *Create_login_sql_serverContext) SetPassword_hash(v antlr.Token)

func (*Create_login_sql_serverContext) SetSid

func (*Create_login_sql_serverContext) ToStringTree

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

func (*Create_login_sql_serverContext) UNLOCK

func (*Create_login_sql_serverContext) WINDOWS

func (*Create_login_sql_serverContext) WITH

type Create_master_key_azure_sqlContext

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

func NewCreate_master_key_azure_sqlContext

func NewCreate_master_key_azure_sqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_master_key_azure_sqlContext

func NewEmptyCreate_master_key_azure_sqlContext

func NewEmptyCreate_master_key_azure_sqlContext() *Create_master_key_azure_sqlContext

func (*Create_master_key_azure_sqlContext) BY

func (*Create_master_key_azure_sqlContext) CREATE

func (*Create_master_key_azure_sqlContext) ENCRYPTION

func (*Create_master_key_azure_sqlContext) EQUAL

func (*Create_master_key_azure_sqlContext) EnterRule

func (*Create_master_key_azure_sqlContext) ExitRule

func (*Create_master_key_azure_sqlContext) GetParser

func (*Create_master_key_azure_sqlContext) GetPassword

func (*Create_master_key_azure_sqlContext) GetRuleContext

func (*Create_master_key_azure_sqlContext) IsCreate_master_key_azure_sqlContext

func (*Create_master_key_azure_sqlContext) IsCreate_master_key_azure_sqlContext()

func (*Create_master_key_azure_sqlContext) KEY

func (*Create_master_key_azure_sqlContext) MASTER

func (*Create_master_key_azure_sqlContext) PASSWORD

func (*Create_master_key_azure_sqlContext) STRING

func (*Create_master_key_azure_sqlContext) SetPassword

func (*Create_master_key_azure_sqlContext) ToStringTree

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

type Create_master_key_sql_serverContext

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

func NewCreate_master_key_sql_serverContext

func NewCreate_master_key_sql_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_master_key_sql_serverContext

func NewEmptyCreate_master_key_sql_serverContext

func NewEmptyCreate_master_key_sql_serverContext() *Create_master_key_sql_serverContext

func (*Create_master_key_sql_serverContext) BY

func (*Create_master_key_sql_serverContext) CREATE

func (*Create_master_key_sql_serverContext) ENCRYPTION

func (*Create_master_key_sql_serverContext) EQUAL

func (*Create_master_key_sql_serverContext) EnterRule

func (*Create_master_key_sql_serverContext) ExitRule

func (*Create_master_key_sql_serverContext) GetParser

func (*Create_master_key_sql_serverContext) GetPassword

func (*Create_master_key_sql_serverContext) GetRuleContext

func (*Create_master_key_sql_serverContext) IsCreate_master_key_sql_serverContext

func (*Create_master_key_sql_serverContext) IsCreate_master_key_sql_serverContext()

func (*Create_master_key_sql_serverContext) KEY

func (*Create_master_key_sql_serverContext) MASTER

func (*Create_master_key_sql_serverContext) PASSWORD

func (*Create_master_key_sql_serverContext) STRING

func (*Create_master_key_sql_serverContext) SetPassword

func (*Create_master_key_sql_serverContext) ToStringTree

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

type Create_or_alter_broker_priorityContext

type Create_or_alter_broker_priorityContext struct {
	*antlr.BaseParserRuleContext

	ConversationPriorityName IIdContext
	RemoteServiceName        antlr.Token
	PriorityValue            antlr.Token
	// contains filtered or unexported fields
}

func NewCreate_or_alter_broker_priorityContext

func NewCreate_or_alter_broker_priorityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_broker_priorityContext

func NewEmptyCreate_or_alter_broker_priorityContext

func NewEmptyCreate_or_alter_broker_priorityContext() *Create_or_alter_broker_priorityContext

func (*Create_or_alter_broker_priorityContext) ALTER

func (*Create_or_alter_broker_priorityContext) ANY

func (*Create_or_alter_broker_priorityContext) AllANY

func (*Create_or_alter_broker_priorityContext) AllCOMMA

func (*Create_or_alter_broker_priorityContext) AllEQUAL

func (*Create_or_alter_broker_priorityContext) AllId

func (*Create_or_alter_broker_priorityContext) BROKER

func (*Create_or_alter_broker_priorityContext) COMMA

func (*Create_or_alter_broker_priorityContext) CONTRACT_NAME

func (*Create_or_alter_broker_priorityContext) CONVERSATION

func (*Create_or_alter_broker_priorityContext) CREATE

func (*Create_or_alter_broker_priorityContext) DECIMAL

func (*Create_or_alter_broker_priorityContext) DEFAULT

func (*Create_or_alter_broker_priorityContext) DOUBLE_FORWARD_SLASH

func (s *Create_or_alter_broker_priorityContext) DOUBLE_FORWARD_SLASH() antlr.TerminalNode

func (*Create_or_alter_broker_priorityContext) EQUAL

func (*Create_or_alter_broker_priorityContext) EnterRule

func (*Create_or_alter_broker_priorityContext) ExitRule

func (*Create_or_alter_broker_priorityContext) FOR

func (*Create_or_alter_broker_priorityContext) GetConversationPriorityName

func (s *Create_or_alter_broker_priorityContext) GetConversationPriorityName() IIdContext

func (*Create_or_alter_broker_priorityContext) GetParser

func (*Create_or_alter_broker_priorityContext) GetPriorityValue

func (s *Create_or_alter_broker_priorityContext) GetPriorityValue() antlr.Token

func (*Create_or_alter_broker_priorityContext) GetRemoteServiceName

func (s *Create_or_alter_broker_priorityContext) GetRemoteServiceName() antlr.Token

func (*Create_or_alter_broker_priorityContext) GetRuleContext

func (*Create_or_alter_broker_priorityContext) Id

func (*Create_or_alter_broker_priorityContext) IsCreate_or_alter_broker_priorityContext

func (*Create_or_alter_broker_priorityContext) IsCreate_or_alter_broker_priorityContext()

func (*Create_or_alter_broker_priorityContext) LOCAL_SERVICE_NAME

func (*Create_or_alter_broker_priorityContext) LR_BRACKET

func (*Create_or_alter_broker_priorityContext) PRIORITY

func (*Create_or_alter_broker_priorityContext) PRIORITY_LEVEL

func (*Create_or_alter_broker_priorityContext) REMOTE_SERVICE_NAME

func (*Create_or_alter_broker_priorityContext) RR_BRACKET

func (*Create_or_alter_broker_priorityContext) SET

func (*Create_or_alter_broker_priorityContext) STRING

func (*Create_or_alter_broker_priorityContext) SetConversationPriorityName

func (s *Create_or_alter_broker_priorityContext) SetConversationPriorityName(v IIdContext)

func (*Create_or_alter_broker_priorityContext) SetPriorityValue

func (s *Create_or_alter_broker_priorityContext) SetPriorityValue(v antlr.Token)

func (*Create_or_alter_broker_priorityContext) SetRemoteServiceName

func (s *Create_or_alter_broker_priorityContext) SetRemoteServiceName(v antlr.Token)

func (*Create_or_alter_broker_priorityContext) ToStringTree

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

type Create_or_alter_ddl_triggerContext

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

func NewCreate_or_alter_ddl_triggerContext

func NewCreate_or_alter_ddl_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_ddl_triggerContext

func NewEmptyCreate_or_alter_ddl_triggerContext

func NewEmptyCreate_or_alter_ddl_triggerContext() *Create_or_alter_ddl_triggerContext

func (*Create_or_alter_ddl_triggerContext) AFTER

func (*Create_or_alter_ddl_triggerContext) ALL

func (*Create_or_alter_ddl_triggerContext) ALTER

func (*Create_or_alter_ddl_triggerContext) AS

func (*Create_or_alter_ddl_triggerContext) AllCOMMA

func (*Create_or_alter_ddl_triggerContext) AllDml_trigger_operation

func (s *Create_or_alter_ddl_triggerContext) AllDml_trigger_operation() []IDml_trigger_operationContext

func (*Create_or_alter_ddl_triggerContext) AllDml_trigger_option

func (*Create_or_alter_ddl_triggerContext) COMMA

func (*Create_or_alter_ddl_triggerContext) CREATE

func (*Create_or_alter_ddl_triggerContext) DATABASE

func (*Create_or_alter_ddl_triggerContext) Ddl_trigger_operation

func (*Create_or_alter_ddl_triggerContext) Dml_trigger_operation

func (*Create_or_alter_ddl_triggerContext) Dml_trigger_option

func (*Create_or_alter_ddl_triggerContext) EnterRule

func (*Create_or_alter_ddl_triggerContext) ExitRule

func (*Create_or_alter_ddl_triggerContext) FOR

func (*Create_or_alter_ddl_triggerContext) GetParser

func (*Create_or_alter_ddl_triggerContext) GetRuleContext

func (*Create_or_alter_ddl_triggerContext) IsCreate_or_alter_ddl_triggerContext

func (*Create_or_alter_ddl_triggerContext) IsCreate_or_alter_ddl_triggerContext()

func (*Create_or_alter_ddl_triggerContext) ON

func (*Create_or_alter_ddl_triggerContext) OR

func (*Create_or_alter_ddl_triggerContext) SERVER

func (*Create_or_alter_ddl_triggerContext) Simple_id

func (*Create_or_alter_ddl_triggerContext) Sql_clauses

func (*Create_or_alter_ddl_triggerContext) TRIGGER

func (*Create_or_alter_ddl_triggerContext) ToStringTree

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

func (*Create_or_alter_ddl_triggerContext) WITH

type Create_or_alter_dml_triggerContext

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

func NewCreate_or_alter_dml_triggerContext

func NewCreate_or_alter_dml_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_dml_triggerContext

func NewEmptyCreate_or_alter_dml_triggerContext

func NewEmptyCreate_or_alter_dml_triggerContext() *Create_or_alter_dml_triggerContext

func (*Create_or_alter_dml_triggerContext) AFTER

func (*Create_or_alter_dml_triggerContext) ALTER

func (*Create_or_alter_dml_triggerContext) APPEND

func (*Create_or_alter_dml_triggerContext) AS

func (*Create_or_alter_dml_triggerContext) AllCOMMA

func (*Create_or_alter_dml_triggerContext) AllDml_trigger_operation

func (s *Create_or_alter_dml_triggerContext) AllDml_trigger_operation() []IDml_trigger_operationContext

func (*Create_or_alter_dml_triggerContext) AllDml_trigger_option

func (*Create_or_alter_dml_triggerContext) AllFOR

func (*Create_or_alter_dml_triggerContext) AllWITH

func (*Create_or_alter_dml_triggerContext) COMMA

func (*Create_or_alter_dml_triggerContext) CREATE

func (*Create_or_alter_dml_triggerContext) Dml_trigger_operation

func (*Create_or_alter_dml_triggerContext) Dml_trigger_option

func (*Create_or_alter_dml_triggerContext) EnterRule

func (*Create_or_alter_dml_triggerContext) ExitRule

func (*Create_or_alter_dml_triggerContext) FOR

func (*Create_or_alter_dml_triggerContext) GetParser

func (*Create_or_alter_dml_triggerContext) GetRuleContext

func (*Create_or_alter_dml_triggerContext) INSTEAD

func (*Create_or_alter_dml_triggerContext) IsCreate_or_alter_dml_triggerContext

func (*Create_or_alter_dml_triggerContext) IsCreate_or_alter_dml_triggerContext()

func (*Create_or_alter_dml_triggerContext) NOT

func (*Create_or_alter_dml_triggerContext) OF

func (*Create_or_alter_dml_triggerContext) ON

func (*Create_or_alter_dml_triggerContext) OR

func (*Create_or_alter_dml_triggerContext) REPLICATION

func (*Create_or_alter_dml_triggerContext) Simple_name

func (*Create_or_alter_dml_triggerContext) Sql_clauses

func (*Create_or_alter_dml_triggerContext) TRIGGER

func (*Create_or_alter_dml_triggerContext) Table_name

func (*Create_or_alter_dml_triggerContext) ToStringTree

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

func (*Create_or_alter_dml_triggerContext) WITH

type Create_or_alter_event_sessionContext

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

func NewCreate_or_alter_event_sessionContext

func NewCreate_or_alter_event_sessionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_event_sessionContext

func NewEmptyCreate_or_alter_event_sessionContext

func NewEmptyCreate_or_alter_event_sessionContext() *Create_or_alter_event_sessionContext

func (*Create_or_alter_event_sessionContext) ACTION

func (*Create_or_alter_event_sessionContext) ADD

func (*Create_or_alter_event_sessionContext) ALLOW_MULTIPLE_EVENT_LOSS

func (s *Create_or_alter_event_sessionContext) ALLOW_MULTIPLE_EVENT_LOSS() antlr.TerminalNode

func (*Create_or_alter_event_sessionContext) ALLOW_SINGLE_EVENT_LOSS

func (s *Create_or_alter_event_sessionContext) ALLOW_SINGLE_EVENT_LOSS() antlr.TerminalNode

func (*Create_or_alter_event_sessionContext) ALTER

func (*Create_or_alter_event_sessionContext) AllACTION

func (*Create_or_alter_event_sessionContext) AllADD

func (*Create_or_alter_event_sessionContext) AllCOMMA

func (*Create_or_alter_event_sessionContext) AllDECIMAL

func (*Create_or_alter_event_sessionContext) AllDOT

func (*Create_or_alter_event_sessionContext) AllDROP

func (*Create_or_alter_event_sessionContext) AllEQUAL

func (*Create_or_alter_event_sessionContext) AllEVENT

func (*Create_or_alter_event_sessionContext) AllEvent_session_predicate_expression

func (s *Create_or_alter_event_sessionContext) AllEvent_session_predicate_expression() []IEvent_session_predicate_expressionContext

func (*Create_or_alter_event_sessionContext) AllId

func (*Create_or_alter_event_sessionContext) AllKB

func (*Create_or_alter_event_sessionContext) AllLR_BRACKET

func (*Create_or_alter_event_sessionContext) AllMB

func (*Create_or_alter_event_sessionContext) AllOFF

func (*Create_or_alter_event_sessionContext) AllON

func (*Create_or_alter_event_sessionContext) AllRR_BRACKET

func (*Create_or_alter_event_sessionContext) AllSET

func (*Create_or_alter_event_sessionContext) AllSTRING

func (*Create_or_alter_event_sessionContext) AllTARGET

func (*Create_or_alter_event_sessionContext) AllWHERE

func (*Create_or_alter_event_sessionContext) COMMA

func (*Create_or_alter_event_sessionContext) CREATE

func (*Create_or_alter_event_sessionContext) DECIMAL

func (*Create_or_alter_event_sessionContext) DOT

func (*Create_or_alter_event_sessionContext) DROP

func (*Create_or_alter_event_sessionContext) EQUAL

func (*Create_or_alter_event_sessionContext) EVENT

func (*Create_or_alter_event_sessionContext) EVENT_RETENTION_MODE

func (s *Create_or_alter_event_sessionContext) EVENT_RETENTION_MODE() antlr.TerminalNode

func (*Create_or_alter_event_sessionContext) EnterRule

func (*Create_or_alter_event_sessionContext) Event_session_predicate_expression

func (*Create_or_alter_event_sessionContext) ExitRule

func (*Create_or_alter_event_sessionContext) GetAction_name

func (*Create_or_alter_event_sessionContext) GetEvent_customizable_attributue

func (s *Create_or_alter_event_sessionContext) GetEvent_customizable_attributue() IIdContext

func (*Create_or_alter_event_sessionContext) GetEvent_module_guid

func (s *Create_or_alter_event_sessionContext) GetEvent_module_guid() IIdContext

func (*Create_or_alter_event_sessionContext) GetEvent_name

func (*Create_or_alter_event_sessionContext) GetEvent_package_name

func (s *Create_or_alter_event_sessionContext) GetEvent_package_name() IIdContext

func (*Create_or_alter_event_sessionContext) GetEvent_session_name

func (s *Create_or_alter_event_sessionContext) GetEvent_session_name() IIdContext

func (*Create_or_alter_event_sessionContext) GetMax_dispatch_latency_seconds

func (s *Create_or_alter_event_sessionContext) GetMax_dispatch_latency_seconds() antlr.Token

func (*Create_or_alter_event_sessionContext) GetMax_event_size

func (s *Create_or_alter_event_sessionContext) GetMax_event_size() antlr.Token

func (*Create_or_alter_event_sessionContext) GetMax_memory

func (*Create_or_alter_event_sessionContext) GetParser

func (*Create_or_alter_event_sessionContext) GetRuleContext

func (*Create_or_alter_event_sessionContext) GetTarget_name

func (*Create_or_alter_event_sessionContext) GetTarget_parameter_name

func (s *Create_or_alter_event_sessionContext) GetTarget_parameter_name() IIdContext

func (*Create_or_alter_event_sessionContext) INFINITE

func (*Create_or_alter_event_sessionContext) Id

func (*Create_or_alter_event_sessionContext) IsCreate_or_alter_event_sessionContext

func (*Create_or_alter_event_sessionContext) IsCreate_or_alter_event_sessionContext()

func (*Create_or_alter_event_sessionContext) KB

func (*Create_or_alter_event_sessionContext) LR_BRACKET

func (*Create_or_alter_event_sessionContext) MAX_DISPATCH_LATENCY

func (s *Create_or_alter_event_sessionContext) MAX_DISPATCH_LATENCY() antlr.TerminalNode

func (*Create_or_alter_event_sessionContext) MAX_EVENT_SIZE

func (*Create_or_alter_event_sessionContext) MAX_MEMORY

func (*Create_or_alter_event_sessionContext) MB

func (*Create_or_alter_event_sessionContext) MEMORY_PARTITION_MODE

func (s *Create_or_alter_event_sessionContext) MEMORY_PARTITION_MODE() antlr.TerminalNode

func (*Create_or_alter_event_sessionContext) NONE

func (*Create_or_alter_event_sessionContext) NO_EVENT_LOSS

func (*Create_or_alter_event_sessionContext) OFF

func (*Create_or_alter_event_sessionContext) ON

func (*Create_or_alter_event_sessionContext) PER_CPU

func (*Create_or_alter_event_sessionContext) PER_NODE

func (*Create_or_alter_event_sessionContext) RR_BRACKET

func (*Create_or_alter_event_sessionContext) SECONDS

func (*Create_or_alter_event_sessionContext) SERVER

func (*Create_or_alter_event_sessionContext) SESSION

func (*Create_or_alter_event_sessionContext) SET

func (*Create_or_alter_event_sessionContext) START

func (*Create_or_alter_event_sessionContext) STARTUP_STATE

func (*Create_or_alter_event_sessionContext) STATE

func (*Create_or_alter_event_sessionContext) STOP

func (*Create_or_alter_event_sessionContext) STRING

func (*Create_or_alter_event_sessionContext) SetAction_name

func (s *Create_or_alter_event_sessionContext) SetAction_name(v IIdContext)

func (*Create_or_alter_event_sessionContext) SetEvent_customizable_attributue

func (s *Create_or_alter_event_sessionContext) SetEvent_customizable_attributue(v IIdContext)

func (*Create_or_alter_event_sessionContext) SetEvent_module_guid

func (s *Create_or_alter_event_sessionContext) SetEvent_module_guid(v IIdContext)

func (*Create_or_alter_event_sessionContext) SetEvent_name

func (*Create_or_alter_event_sessionContext) SetEvent_package_name

func (s *Create_or_alter_event_sessionContext) SetEvent_package_name(v IIdContext)

func (*Create_or_alter_event_sessionContext) SetEvent_session_name

func (s *Create_or_alter_event_sessionContext) SetEvent_session_name(v IIdContext)

func (*Create_or_alter_event_sessionContext) SetMax_dispatch_latency_seconds

func (s *Create_or_alter_event_sessionContext) SetMax_dispatch_latency_seconds(v antlr.Token)

func (*Create_or_alter_event_sessionContext) SetMax_event_size

func (s *Create_or_alter_event_sessionContext) SetMax_event_size(v antlr.Token)

func (*Create_or_alter_event_sessionContext) SetMax_memory

func (s *Create_or_alter_event_sessionContext) SetMax_memory(v antlr.Token)

func (*Create_or_alter_event_sessionContext) SetTarget_name

func (s *Create_or_alter_event_sessionContext) SetTarget_name(v IIdContext)

func (*Create_or_alter_event_sessionContext) SetTarget_parameter_name

func (s *Create_or_alter_event_sessionContext) SetTarget_parameter_name(v IIdContext)

func (*Create_or_alter_event_sessionContext) TARGET

func (*Create_or_alter_event_sessionContext) TRACK_CAUSALITY

func (*Create_or_alter_event_sessionContext) ToStringTree

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

func (*Create_or_alter_event_sessionContext) WHERE

func (*Create_or_alter_event_sessionContext) WITH

type Create_or_alter_functionContext

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

func NewCreate_or_alter_functionContext

func NewCreate_or_alter_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_functionContext

func NewEmptyCreate_or_alter_functionContext

func NewEmptyCreate_or_alter_functionContext() *Create_or_alter_functionContext

func (*Create_or_alter_functionContext) ALTER

func (*Create_or_alter_functionContext) AllCOMMA

func (*Create_or_alter_functionContext) AllProcedure_param

func (s *Create_or_alter_functionContext) AllProcedure_param() []IProcedure_paramContext

func (*Create_or_alter_functionContext) COMMA

func (*Create_or_alter_functionContext) CREATE

func (*Create_or_alter_functionContext) EnterRule

func (*Create_or_alter_functionContext) ExitRule

func (*Create_or_alter_functionContext) FUNCTION

func (*Create_or_alter_functionContext) Func_body_returns_scalar

func (*Create_or_alter_functionContext) Func_body_returns_select

func (*Create_or_alter_functionContext) Func_body_returns_table

func (*Create_or_alter_functionContext) Func_proc_name_schema

func (*Create_or_alter_functionContext) GetParser

func (*Create_or_alter_functionContext) GetRuleContext

func (*Create_or_alter_functionContext) IsCreate_or_alter_functionContext

func (*Create_or_alter_functionContext) IsCreate_or_alter_functionContext()

func (*Create_or_alter_functionContext) LR_BRACKET

func (*Create_or_alter_functionContext) OR

func (*Create_or_alter_functionContext) Procedure_param

func (*Create_or_alter_functionContext) RR_BRACKET

func (*Create_or_alter_functionContext) SEMI

func (*Create_or_alter_functionContext) ToStringTree

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

type Create_or_alter_procedureContext

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

func NewCreate_or_alter_procedureContext

func NewCreate_or_alter_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_procedureContext

func NewEmptyCreate_or_alter_procedureContext

func NewEmptyCreate_or_alter_procedureContext() *Create_or_alter_procedureContext

func (*Create_or_alter_procedureContext) ALTER

func (*Create_or_alter_procedureContext) AS

func (*Create_or_alter_procedureContext) AllCOMMA

func (*Create_or_alter_procedureContext) AllProcedure_option

func (*Create_or_alter_procedureContext) AllProcedure_param

func (*Create_or_alter_procedureContext) COMMA

func (*Create_or_alter_procedureContext) CREATE

func (*Create_or_alter_procedureContext) DECIMAL

func (*Create_or_alter_procedureContext) EnterRule

func (*Create_or_alter_procedureContext) ExitRule

func (*Create_or_alter_procedureContext) FOR

func (*Create_or_alter_procedureContext) Func_proc_name_schema

func (*Create_or_alter_procedureContext) GetParser

func (*Create_or_alter_procedureContext) GetProc

func (*Create_or_alter_procedureContext) GetRuleContext

func (*Create_or_alter_procedureContext) IsCreate_or_alter_procedureContext

func (*Create_or_alter_procedureContext) IsCreate_or_alter_procedureContext()

func (*Create_or_alter_procedureContext) LR_BRACKET

func (*Create_or_alter_procedureContext) OR

func (*Create_or_alter_procedureContext) PROC

func (*Create_or_alter_procedureContext) PROCEDURE

func (*Create_or_alter_procedureContext) Procedure_option

func (*Create_or_alter_procedureContext) Procedure_param

func (*Create_or_alter_procedureContext) REPLICATION

func (*Create_or_alter_procedureContext) RR_BRACKET

func (*Create_or_alter_procedureContext) SEMI

func (*Create_or_alter_procedureContext) SetProc

func (*Create_or_alter_procedureContext) Sql_clauses

func (*Create_or_alter_procedureContext) ToStringTree

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

func (*Create_or_alter_procedureContext) WITH

type Create_or_alter_triggerContext

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

func NewCreate_or_alter_triggerContext

func NewCreate_or_alter_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_or_alter_triggerContext

func NewEmptyCreate_or_alter_triggerContext

func NewEmptyCreate_or_alter_triggerContext() *Create_or_alter_triggerContext

func (*Create_or_alter_triggerContext) Create_or_alter_ddl_trigger

func (*Create_or_alter_triggerContext) Create_or_alter_dml_trigger

func (*Create_or_alter_triggerContext) EnterRule

func (*Create_or_alter_triggerContext) ExitRule

func (*Create_or_alter_triggerContext) GetParser

func (*Create_or_alter_triggerContext) GetRuleContext

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

func (*Create_or_alter_triggerContext) IsCreate_or_alter_triggerContext

func (*Create_or_alter_triggerContext) IsCreate_or_alter_triggerContext()

func (*Create_or_alter_triggerContext) ToStringTree

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

type Create_queueContext

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

func NewCreate_queueContext

func NewCreate_queueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_queueContext

func NewEmptyCreate_queueContext

func NewEmptyCreate_queueContext() *Create_queueContext

func (*Create_queueContext) AllId

func (s *Create_queueContext) AllId() []IIdContext

func (*Create_queueContext) CREATE

func (*Create_queueContext) DEFAULT

func (s *Create_queueContext) DEFAULT() antlr.TerminalNode

func (*Create_queueContext) EnterRule

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

func (*Create_queueContext) ExitRule

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

func (*Create_queueContext) Full_table_name

func (s *Create_queueContext) Full_table_name() IFull_table_nameContext

func (*Create_queueContext) GetFilegroup

func (s *Create_queueContext) GetFilegroup() IIdContext

func (*Create_queueContext) GetParser

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

func (*Create_queueContext) GetQueue_name

func (s *Create_queueContext) GetQueue_name() IIdContext

func (*Create_queueContext) GetRuleContext

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

func (*Create_queueContext) Id

func (*Create_queueContext) IsCreate_queueContext

func (*Create_queueContext) IsCreate_queueContext()

func (*Create_queueContext) ON

func (*Create_queueContext) QUEUE

func (*Create_queueContext) Queue_settings

func (s *Create_queueContext) Queue_settings() IQueue_settingsContext

func (*Create_queueContext) SetFilegroup

func (s *Create_queueContext) SetFilegroup(v IIdContext)

func (*Create_queueContext) SetQueue_name

func (s *Create_queueContext) SetQueue_name(v IIdContext)

func (*Create_queueContext) ToStringTree

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

type Create_remote_service_bindingContext

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

func NewCreate_remote_service_bindingContext

func NewCreate_remote_service_bindingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_remote_service_bindingContext

func NewEmptyCreate_remote_service_bindingContext

func NewEmptyCreate_remote_service_bindingContext() *Create_remote_service_bindingContext

func (*Create_remote_service_bindingContext) ANONYMOUS

func (*Create_remote_service_bindingContext) AUTHORIZATION

func (*Create_remote_service_bindingContext) AllEQUAL

func (*Create_remote_service_bindingContext) AllId

func (*Create_remote_service_bindingContext) AllSERVICE

func (*Create_remote_service_bindingContext) BINDING

func (*Create_remote_service_bindingContext) COMMA

func (*Create_remote_service_bindingContext) CREATE

func (*Create_remote_service_bindingContext) EQUAL

func (*Create_remote_service_bindingContext) EnterRule

func (*Create_remote_service_bindingContext) ExitRule

func (*Create_remote_service_bindingContext) GetBinding_name

func (s *Create_remote_service_bindingContext) GetBinding_name() IIdContext

func (*Create_remote_service_bindingContext) GetOwner_name

func (*Create_remote_service_bindingContext) GetParser

func (*Create_remote_service_bindingContext) GetRemote_service_name

func (s *Create_remote_service_bindingContext) GetRemote_service_name() antlr.Token

func (*Create_remote_service_bindingContext) GetRuleContext

func (*Create_remote_service_bindingContext) GetUser_name

func (*Create_remote_service_bindingContext) Id

func (*Create_remote_service_bindingContext) IsCreate_remote_service_bindingContext

func (*Create_remote_service_bindingContext) IsCreate_remote_service_bindingContext()

func (*Create_remote_service_bindingContext) OFF

func (*Create_remote_service_bindingContext) ON

func (*Create_remote_service_bindingContext) REMOTE

func (*Create_remote_service_bindingContext) SERVICE

func (*Create_remote_service_bindingContext) STRING

func (*Create_remote_service_bindingContext) SetBinding_name

func (s *Create_remote_service_bindingContext) SetBinding_name(v IIdContext)

func (*Create_remote_service_bindingContext) SetOwner_name

func (*Create_remote_service_bindingContext) SetRemote_service_name

func (s *Create_remote_service_bindingContext) SetRemote_service_name(v antlr.Token)

func (*Create_remote_service_bindingContext) SetUser_name

func (*Create_remote_service_bindingContext) TO

func (*Create_remote_service_bindingContext) ToStringTree

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

func (*Create_remote_service_bindingContext) USER

func (*Create_remote_service_bindingContext) WITH

type Create_resource_poolContext

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

func NewCreate_resource_poolContext

func NewCreate_resource_poolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_resource_poolContext

func NewEmptyCreate_resource_poolContext

func NewEmptyCreate_resource_poolContext() *Create_resource_poolContext

func (*Create_resource_poolContext) AFFINITY

func (*Create_resource_poolContext) AUTO

func (*Create_resource_poolContext) AllCOMMA

func (*Create_resource_poolContext) AllDECIMAL

func (*Create_resource_poolContext) AllEQUAL

func (*Create_resource_poolContext) AllLR_BRACKET

func (s *Create_resource_poolContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Create_resource_poolContext) AllRR_BRACKET

func (s *Create_resource_poolContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Create_resource_poolContext) AllTO

func (*Create_resource_poolContext) CAP_CPU_PERCENT

func (s *Create_resource_poolContext) CAP_CPU_PERCENT() antlr.TerminalNode

func (*Create_resource_poolContext) COMMA

func (*Create_resource_poolContext) CREATE

func (*Create_resource_poolContext) DECIMAL

func (*Create_resource_poolContext) EQUAL

func (*Create_resource_poolContext) EnterRule

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

func (*Create_resource_poolContext) ExitRule

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

func (*Create_resource_poolContext) GetParser

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

func (*Create_resource_poolContext) GetPool_name

func (s *Create_resource_poolContext) GetPool_name() IIdContext

func (*Create_resource_poolContext) GetRuleContext

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

func (*Create_resource_poolContext) Id

func (*Create_resource_poolContext) IsCreate_resource_poolContext

func (*Create_resource_poolContext) IsCreate_resource_poolContext()

func (*Create_resource_poolContext) LR_BRACKET

func (*Create_resource_poolContext) MAX_CPU_PERCENT

func (s *Create_resource_poolContext) MAX_CPU_PERCENT() antlr.TerminalNode

func (*Create_resource_poolContext) MAX_IOPS_PER_VOLUME

func (s *Create_resource_poolContext) MAX_IOPS_PER_VOLUME() antlr.TerminalNode

func (*Create_resource_poolContext) MAX_MEMORY_PERCENT

func (s *Create_resource_poolContext) MAX_MEMORY_PERCENT() antlr.TerminalNode

func (*Create_resource_poolContext) MIN_CPU_PERCENT

func (s *Create_resource_poolContext) MIN_CPU_PERCENT() antlr.TerminalNode

func (*Create_resource_poolContext) MIN_IOPS_PER_VOLUME

func (s *Create_resource_poolContext) MIN_IOPS_PER_VOLUME() antlr.TerminalNode

func (*Create_resource_poolContext) MIN_MEMORY_PERCENT

func (s *Create_resource_poolContext) MIN_MEMORY_PERCENT() antlr.TerminalNode

func (*Create_resource_poolContext) NUMANODE

func (*Create_resource_poolContext) POOL

func (*Create_resource_poolContext) RESOURCE

func (*Create_resource_poolContext) RR_BRACKET

func (*Create_resource_poolContext) SCHEDULER

func (*Create_resource_poolContext) SetPool_name

func (s *Create_resource_poolContext) SetPool_name(v IIdContext)

func (*Create_resource_poolContext) TO

func (*Create_resource_poolContext) ToStringTree

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

func (*Create_resource_poolContext) WITH

type Create_routeContext

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

func NewCreate_routeContext

func NewCreate_routeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_routeContext

func NewEmptyCreate_routeContext

func NewEmptyCreate_routeContext() *Create_routeContext

func (*Create_routeContext) ADDRESS

func (s *Create_routeContext) ADDRESS() antlr.TerminalNode

func (*Create_routeContext) AUTHORIZATION

func (s *Create_routeContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_routeContext) AllCOMMA

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

func (*Create_routeContext) AllEQUAL

func (s *Create_routeContext) AllEQUAL() []antlr.TerminalNode

func (*Create_routeContext) AllId

func (s *Create_routeContext) AllId() []IIdContext

func (*Create_routeContext) AllQUOTED_URL

func (s *Create_routeContext) AllQUOTED_URL() []antlr.TerminalNode

func (*Create_routeContext) AllSTRING

func (s *Create_routeContext) AllSTRING() []antlr.TerminalNode

func (*Create_routeContext) BROKER_INSTANCE

func (s *Create_routeContext) BROKER_INSTANCE() antlr.TerminalNode

func (*Create_routeContext) COMMA

func (*Create_routeContext) CREATE

func (*Create_routeContext) DECIMAL

func (s *Create_routeContext) DECIMAL() antlr.TerminalNode

func (*Create_routeContext) EQUAL

func (*Create_routeContext) EnterRule

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

func (*Create_routeContext) ExitRule

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

func (*Create_routeContext) GetBroker_instance_identifier

func (s *Create_routeContext) GetBroker_instance_identifier() antlr.Token

func (*Create_routeContext) GetOwner_name

func (s *Create_routeContext) GetOwner_name() IIdContext

func (*Create_routeContext) GetParser

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

func (*Create_routeContext) GetRoute_name

func (s *Create_routeContext) GetRoute_name() IIdContext

func (*Create_routeContext) GetRoute_service_name

func (s *Create_routeContext) GetRoute_service_name() antlr.Token

func (*Create_routeContext) GetRuleContext

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

func (*Create_routeContext) Id

func (*Create_routeContext) IsCreate_routeContext

func (*Create_routeContext) IsCreate_routeContext()

func (*Create_routeContext) LIFETIME

func (s *Create_routeContext) LIFETIME() antlr.TerminalNode

func (*Create_routeContext) MIRROR_ADDRESS

func (s *Create_routeContext) MIRROR_ADDRESS() antlr.TerminalNode

func (*Create_routeContext) QUOTED_URL

func (s *Create_routeContext) QUOTED_URL(i int) antlr.TerminalNode

func (*Create_routeContext) ROUTE

func (*Create_routeContext) SERVICE_NAME

func (s *Create_routeContext) SERVICE_NAME() antlr.TerminalNode

func (*Create_routeContext) STRING

func (*Create_routeContext) SetBroker_instance_identifier

func (s *Create_routeContext) SetBroker_instance_identifier(v antlr.Token)

func (*Create_routeContext) SetOwner_name

func (s *Create_routeContext) SetOwner_name(v IIdContext)

func (*Create_routeContext) SetRoute_name

func (s *Create_routeContext) SetRoute_name(v IIdContext)

func (*Create_routeContext) SetRoute_service_name

func (s *Create_routeContext) SetRoute_service_name(v antlr.Token)

func (*Create_routeContext) ToStringTree

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

func (*Create_routeContext) WITH

type Create_ruleContext

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

func NewCreate_ruleContext

func NewCreate_ruleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_ruleContext

func NewEmptyCreate_ruleContext

func NewEmptyCreate_ruleContext() *Create_ruleContext

func (*Create_ruleContext) AS

func (*Create_ruleContext) AllId

func (s *Create_ruleContext) AllId() []IIdContext

func (*Create_ruleContext) CREATE

func (*Create_ruleContext) DOT

func (*Create_ruleContext) EnterRule

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

func (*Create_ruleContext) ExitRule

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

func (*Create_ruleContext) GetParser

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

func (*Create_ruleContext) GetRuleContext

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

func (*Create_ruleContext) GetRule_name

func (s *Create_ruleContext) GetRule_name() IIdContext

func (*Create_ruleContext) GetSchema_name

func (s *Create_ruleContext) GetSchema_name() IIdContext

func (*Create_ruleContext) Id

func (*Create_ruleContext) IsCreate_ruleContext

func (*Create_ruleContext) IsCreate_ruleContext()

func (*Create_ruleContext) RULE

func (*Create_ruleContext) Search_condition

func (s *Create_ruleContext) Search_condition() ISearch_conditionContext

func (*Create_ruleContext) SetRule_name

func (s *Create_ruleContext) SetRule_name(v IIdContext)

func (*Create_ruleContext) SetSchema_name

func (s *Create_ruleContext) SetSchema_name(v IIdContext)

func (*Create_ruleContext) ToStringTree

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

type Create_schemaContext

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

func NewCreate_schemaContext

func NewCreate_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_schemaContext

func NewEmptyCreate_schemaContext

func NewEmptyCreate_schemaContext() *Create_schemaContext

func (*Create_schemaContext) AUTHORIZATION

func (s *Create_schemaContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_schemaContext) AllCOLON

func (s *Create_schemaContext) AllCOLON() []antlr.TerminalNode

func (*Create_schemaContext) AllCreate_table

func (s *Create_schemaContext) AllCreate_table() []ICreate_tableContext

func (*Create_schemaContext) AllCreate_view

func (s *Create_schemaContext) AllCreate_view() []ICreate_viewContext

func (*Create_schemaContext) AllDELETE

func (s *Create_schemaContext) AllDELETE() []antlr.TerminalNode

func (*Create_schemaContext) AllDENY

func (s *Create_schemaContext) AllDENY() []antlr.TerminalNode

func (*Create_schemaContext) AllFROM

func (s *Create_schemaContext) AllFROM() []antlr.TerminalNode

func (*Create_schemaContext) AllGRANT

func (s *Create_schemaContext) AllGRANT() []antlr.TerminalNode

func (*Create_schemaContext) AllINSERT

func (s *Create_schemaContext) AllINSERT() []antlr.TerminalNode

func (*Create_schemaContext) AllId

func (s *Create_schemaContext) AllId() []IIdContext

func (*Create_schemaContext) AllON

func (*Create_schemaContext) AllREVOKE

func (s *Create_schemaContext) AllREVOKE() []antlr.TerminalNode

func (*Create_schemaContext) AllSCHEMA

func (s *Create_schemaContext) AllSCHEMA() []antlr.TerminalNode

func (*Create_schemaContext) AllSELECT

func (s *Create_schemaContext) AllSELECT() []antlr.TerminalNode

func (*Create_schemaContext) AllTO

func (*Create_schemaContext) AllUPDATE

func (s *Create_schemaContext) AllUPDATE() []antlr.TerminalNode

func (*Create_schemaContext) COLON

func (*Create_schemaContext) CREATE

func (*Create_schemaContext) Create_table

func (s *Create_schemaContext) Create_table(i int) ICreate_tableContext

func (*Create_schemaContext) Create_view

func (s *Create_schemaContext) Create_view(i int) ICreate_viewContext

func (*Create_schemaContext) DELETE

func (*Create_schemaContext) DENY

func (*Create_schemaContext) EnterRule

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

func (*Create_schemaContext) ExitRule

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

func (*Create_schemaContext) FROM

func (*Create_schemaContext) GRANT

func (*Create_schemaContext) GetObject_name

func (s *Create_schemaContext) GetObject_name() IIdContext

func (*Create_schemaContext) GetOwner_name

func (s *Create_schemaContext) GetOwner_name() IIdContext

func (*Create_schemaContext) GetParser

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

func (*Create_schemaContext) GetRuleContext

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

func (*Create_schemaContext) GetSchema_name

func (s *Create_schemaContext) GetSchema_name() IIdContext

func (*Create_schemaContext) INSERT

func (*Create_schemaContext) Id

func (*Create_schemaContext) IsCreate_schemaContext

func (*Create_schemaContext) IsCreate_schemaContext()

func (*Create_schemaContext) ON

func (*Create_schemaContext) REVOKE

func (*Create_schemaContext) SCHEMA

func (*Create_schemaContext) SELECT

func (*Create_schemaContext) SetObject_name

func (s *Create_schemaContext) SetObject_name(v IIdContext)

func (*Create_schemaContext) SetOwner_name

func (s *Create_schemaContext) SetOwner_name(v IIdContext)

func (*Create_schemaContext) SetSchema_name

func (s *Create_schemaContext) SetSchema_name(v IIdContext)

func (*Create_schemaContext) TO

func (*Create_schemaContext) ToStringTree

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

func (*Create_schemaContext) UPDATE

type Create_schema_azure_sql_dw_and_pdwContext

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

func NewCreate_schema_azure_sql_dw_and_pdwContext

func NewCreate_schema_azure_sql_dw_and_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_schema_azure_sql_dw_and_pdwContext

func NewEmptyCreate_schema_azure_sql_dw_and_pdwContext

func NewEmptyCreate_schema_azure_sql_dw_and_pdwContext() *Create_schema_azure_sql_dw_and_pdwContext

func (*Create_schema_azure_sql_dw_and_pdwContext) AUTHORIZATION

func (*Create_schema_azure_sql_dw_and_pdwContext) AllId

func (*Create_schema_azure_sql_dw_and_pdwContext) CREATE

func (*Create_schema_azure_sql_dw_and_pdwContext) EnterRule

func (*Create_schema_azure_sql_dw_and_pdwContext) ExitRule

func (*Create_schema_azure_sql_dw_and_pdwContext) GetOwner_name

func (*Create_schema_azure_sql_dw_and_pdwContext) GetParser

func (*Create_schema_azure_sql_dw_and_pdwContext) GetRuleContext

func (*Create_schema_azure_sql_dw_and_pdwContext) GetSchema_name

func (*Create_schema_azure_sql_dw_and_pdwContext) Id

func (*Create_schema_azure_sql_dw_and_pdwContext) IsCreate_schema_azure_sql_dw_and_pdwContext

func (*Create_schema_azure_sql_dw_and_pdwContext) IsCreate_schema_azure_sql_dw_and_pdwContext()

func (*Create_schema_azure_sql_dw_and_pdwContext) SCHEMA

func (*Create_schema_azure_sql_dw_and_pdwContext) SetOwner_name

func (*Create_schema_azure_sql_dw_and_pdwContext) SetSchema_name

func (*Create_schema_azure_sql_dw_and_pdwContext) ToStringTree

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

type Create_search_property_listContext

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

func NewCreate_search_property_listContext

func NewCreate_search_property_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_search_property_listContext

func NewEmptyCreate_search_property_listContext

func NewEmptyCreate_search_property_listContext() *Create_search_property_listContext

func (*Create_search_property_listContext) AUTHORIZATION

func (*Create_search_property_listContext) AllId

func (*Create_search_property_listContext) CREATE

func (*Create_search_property_listContext) DOT

func (*Create_search_property_listContext) EnterRule

func (*Create_search_property_listContext) ExitRule

func (*Create_search_property_listContext) FROM

func (*Create_search_property_listContext) GetDatabase_name

func (s *Create_search_property_listContext) GetDatabase_name() IIdContext

func (*Create_search_property_listContext) GetNew_list_name

func (s *Create_search_property_listContext) GetNew_list_name() IIdContext

func (*Create_search_property_listContext) GetOwner_name

func (*Create_search_property_listContext) GetParser

func (*Create_search_property_listContext) GetRuleContext

func (*Create_search_property_listContext) GetSource_list_name

func (s *Create_search_property_listContext) GetSource_list_name() IIdContext

func (*Create_search_property_listContext) Id

func (*Create_search_property_listContext) IsCreate_search_property_listContext

func (*Create_search_property_listContext) IsCreate_search_property_listContext()

func (*Create_search_property_listContext) LIST

func (*Create_search_property_listContext) PROPERTY

func (*Create_search_property_listContext) SEARCH

func (*Create_search_property_listContext) SetDatabase_name

func (s *Create_search_property_listContext) SetDatabase_name(v IIdContext)

func (*Create_search_property_listContext) SetNew_list_name

func (s *Create_search_property_listContext) SetNew_list_name(v IIdContext)

func (*Create_search_property_listContext) SetOwner_name

func (s *Create_search_property_listContext) SetOwner_name(v IIdContext)

func (*Create_search_property_listContext) SetSource_list_name

func (s *Create_search_property_listContext) SetSource_list_name(v IIdContext)

func (*Create_search_property_listContext) ToStringTree

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

type Create_security_policyContext

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

func NewCreate_security_policyContext

func NewCreate_security_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_security_policyContext

func NewEmptyCreate_security_policyContext

func NewEmptyCreate_security_policyContext() *Create_security_policyContext

func (*Create_security_policyContext) ADD

func (*Create_security_policyContext) AFTER

func (*Create_security_policyContext) AllADD

func (*Create_security_policyContext) AllAFTER

func (*Create_security_policyContext) AllBEFORE

func (*Create_security_policyContext) AllBLOCK

func (*Create_security_policyContext) AllCOMMA

func (*Create_security_policyContext) AllDELETE

func (*Create_security_policyContext) AllDOT

func (*Create_security_policyContext) AllFILTER

func (*Create_security_policyContext) AllINSERT

func (*Create_security_policyContext) AllId

func (*Create_security_policyContext) AllLR_BRACKET

func (s *Create_security_policyContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Create_security_policyContext) AllOFF

func (*Create_security_policyContext) AllON

func (*Create_security_policyContext) AllPREDICATE

func (s *Create_security_policyContext) AllPREDICATE() []antlr.TerminalNode

func (*Create_security_policyContext) AllRR_BRACKET

func (s *Create_security_policyContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Create_security_policyContext) AllUPDATE

func (*Create_security_policyContext) BEFORE

func (*Create_security_policyContext) BLOCK

func (*Create_security_policyContext) COMMA

func (*Create_security_policyContext) CREATE

func (*Create_security_policyContext) DELETE

func (*Create_security_policyContext) DOT

func (*Create_security_policyContext) EQUAL

func (*Create_security_policyContext) EnterRule

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

func (*Create_security_policyContext) ExitRule

func (*Create_security_policyContext) FILTER

func (*Create_security_policyContext) FOR

func (*Create_security_policyContext) GetColumn_name_or_arguments

func (s *Create_security_policyContext) GetColumn_name_or_arguments() IIdContext

func (*Create_security_policyContext) GetName

func (*Create_security_policyContext) GetParser

func (*Create_security_policyContext) GetRuleContext

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

func (*Create_security_policyContext) GetSchema_name

func (s *Create_security_policyContext) GetSchema_name() IIdContext

func (*Create_security_policyContext) GetSecurity_policy_name

func (s *Create_security_policyContext) GetSecurity_policy_name() IIdContext

func (*Create_security_policyContext) GetSecurity_predicate_function_name

func (s *Create_security_policyContext) GetSecurity_predicate_function_name() IIdContext

func (*Create_security_policyContext) GetTable_schema_name

func (s *Create_security_policyContext) GetTable_schema_name() IIdContext

func (*Create_security_policyContext) GetTvf_schema_name

func (s *Create_security_policyContext) GetTvf_schema_name() IIdContext

func (*Create_security_policyContext) INSERT

func (*Create_security_policyContext) Id

func (*Create_security_policyContext) IsCreate_security_policyContext

func (*Create_security_policyContext) IsCreate_security_policyContext()

func (*Create_security_policyContext) LR_BRACKET

func (*Create_security_policyContext) NOT

func (*Create_security_policyContext) OFF

func (*Create_security_policyContext) ON

func (*Create_security_policyContext) POLICY

func (*Create_security_policyContext) PREDICATE

func (*Create_security_policyContext) REPLICATION

func (*Create_security_policyContext) RR_BRACKET

func (*Create_security_policyContext) SCHEMABINDING

func (*Create_security_policyContext) SECURITY

func (*Create_security_policyContext) STATE

func (*Create_security_policyContext) SetColumn_name_or_arguments

func (s *Create_security_policyContext) SetColumn_name_or_arguments(v IIdContext)

func (*Create_security_policyContext) SetName

func (*Create_security_policyContext) SetSchema_name

func (s *Create_security_policyContext) SetSchema_name(v IIdContext)

func (*Create_security_policyContext) SetSecurity_policy_name

func (s *Create_security_policyContext) SetSecurity_policy_name(v IIdContext)

func (*Create_security_policyContext) SetSecurity_predicate_function_name

func (s *Create_security_policyContext) SetSecurity_predicate_function_name(v IIdContext)

func (*Create_security_policyContext) SetTable_schema_name

func (s *Create_security_policyContext) SetTable_schema_name(v IIdContext)

func (*Create_security_policyContext) SetTvf_schema_name

func (s *Create_security_policyContext) SetTvf_schema_name(v IIdContext)

func (*Create_security_policyContext) ToStringTree

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

func (*Create_security_policyContext) UPDATE

func (*Create_security_policyContext) WITH

type Create_sequenceContext

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

func NewCreate_sequenceContext

func NewCreate_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_sequenceContext

func NewEmptyCreate_sequenceContext

func NewEmptyCreate_sequenceContext() *Create_sequenceContext

func (*Create_sequenceContext) AS

func (*Create_sequenceContext) AllDECIMAL

func (s *Create_sequenceContext) AllDECIMAL() []antlr.TerminalNode

func (*Create_sequenceContext) AllId

func (s *Create_sequenceContext) AllId() []IIdContext

func (*Create_sequenceContext) AllNO

func (*Create_sequenceContext) BY

func (*Create_sequenceContext) CACHE

func (*Create_sequenceContext) CREATE

func (*Create_sequenceContext) CYCLE

func (*Create_sequenceContext) DECIMAL

func (*Create_sequenceContext) DOT

func (*Create_sequenceContext) Data_type

func (*Create_sequenceContext) EnterRule

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

func (*Create_sequenceContext) ExitRule

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

func (*Create_sequenceContext) GetParser

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

func (*Create_sequenceContext) GetRuleContext

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

func (*Create_sequenceContext) GetSchema_name

func (s *Create_sequenceContext) GetSchema_name() IIdContext

func (*Create_sequenceContext) GetSequence_name

func (s *Create_sequenceContext) GetSequence_name() IIdContext

func (*Create_sequenceContext) INCREMENT

func (s *Create_sequenceContext) INCREMENT() antlr.TerminalNode

func (*Create_sequenceContext) Id

func (*Create_sequenceContext) IsCreate_sequenceContext

func (*Create_sequenceContext) IsCreate_sequenceContext()

func (*Create_sequenceContext) MAXVALUE

func (*Create_sequenceContext) MINUS

func (*Create_sequenceContext) MINVALUE

func (*Create_sequenceContext) NO

func (*Create_sequenceContext) SEQUENCE

func (*Create_sequenceContext) START

func (*Create_sequenceContext) SetSchema_name

func (s *Create_sequenceContext) SetSchema_name(v IIdContext)

func (*Create_sequenceContext) SetSequence_name

func (s *Create_sequenceContext) SetSequence_name(v IIdContext)

func (*Create_sequenceContext) ToStringTree

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

func (*Create_sequenceContext) WITH

type Create_server_auditContext

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

func NewCreate_server_auditContext

func NewCreate_server_auditContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_server_auditContext

func NewEmptyCreate_server_auditContext

func NewEmptyCreate_server_auditContext() *Create_server_auditContext

func (*Create_server_auditContext) AND

func (*Create_server_auditContext) APPLICATION_LOG

func (s *Create_server_auditContext) APPLICATION_LOG() antlr.TerminalNode

func (*Create_server_auditContext) AUDIT

func (*Create_server_auditContext) AUDIT_GUID

func (*Create_server_auditContext) AllAUDIT_GUID

func (s *Create_server_auditContext) AllAUDIT_GUID() []antlr.TerminalNode

func (*Create_server_auditContext) AllCOMMA

func (*Create_server_auditContext) AllCONTINUE

func (s *Create_server_auditContext) AllCONTINUE() []antlr.TerminalNode

func (*Create_server_auditContext) AllDECIMAL

func (s *Create_server_auditContext) AllDECIMAL() []antlr.TerminalNode

func (*Create_server_auditContext) AllEQUAL

func (*Create_server_auditContext) AllFAIL_OPERATION

func (s *Create_server_auditContext) AllFAIL_OPERATION() []antlr.TerminalNode

func (*Create_server_auditContext) AllFILEPATH

func (s *Create_server_auditContext) AllFILEPATH() []antlr.TerminalNode

func (*Create_server_auditContext) AllGB

func (*Create_server_auditContext) AllId

func (*Create_server_auditContext) AllLR_BRACKET

func (s *Create_server_auditContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Create_server_auditContext) AllMAXSIZE

func (s *Create_server_auditContext) AllMAXSIZE() []antlr.TerminalNode

func (*Create_server_auditContext) AllMAX_FILES

func (s *Create_server_auditContext) AllMAX_FILES() []antlr.TerminalNode

func (*Create_server_auditContext) AllMAX_ROLLOVER_FILES

func (s *Create_server_auditContext) AllMAX_ROLLOVER_FILES() []antlr.TerminalNode

func (*Create_server_auditContext) AllMB

func (*Create_server_auditContext) AllOFF

func (*Create_server_auditContext) AllON

func (*Create_server_auditContext) AllON_FAILURE

func (s *Create_server_auditContext) AllON_FAILURE() []antlr.TerminalNode

func (*Create_server_auditContext) AllQUEUE_DELAY

func (s *Create_server_auditContext) AllQUEUE_DELAY() []antlr.TerminalNode

func (*Create_server_auditContext) AllRESERVE_DISK_SPACE

func (s *Create_server_auditContext) AllRESERVE_DISK_SPACE() []antlr.TerminalNode

func (*Create_server_auditContext) AllRR_BRACKET

func (s *Create_server_auditContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Create_server_auditContext) AllSHUTDOWN

func (s *Create_server_auditContext) AllSHUTDOWN() []antlr.TerminalNode

func (*Create_server_auditContext) AllSTATE

func (*Create_server_auditContext) AllSTRING

func (*Create_server_auditContext) AllTB

func (*Create_server_auditContext) AllUNLIMITED

func (s *Create_server_auditContext) AllUNLIMITED() []antlr.TerminalNode

func (*Create_server_auditContext) COMMA

func (*Create_server_auditContext) CONTINUE

func (*Create_server_auditContext) CREATE

func (*Create_server_auditContext) DECIMAL

func (*Create_server_auditContext) EQUAL

func (*Create_server_auditContext) EXCLAMATION

func (*Create_server_auditContext) EnterRule

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

func (*Create_server_auditContext) ExitRule

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

func (*Create_server_auditContext) FAIL_OPERATION

func (s *Create_server_auditContext) FAIL_OPERATION(i int) antlr.TerminalNode

func (*Create_server_auditContext) FILE

func (*Create_server_auditContext) FILEPATH

func (*Create_server_auditContext) GB

func (*Create_server_auditContext) GREATER

func (*Create_server_auditContext) GetAudit_guid

func (s *Create_server_auditContext) GetAudit_guid() IIdContext

func (*Create_server_auditContext) GetAudit_name

func (s *Create_server_auditContext) GetAudit_name() IIdContext

func (*Create_server_auditContext) GetEvent_field_name

func (s *Create_server_auditContext) GetEvent_field_name() IIdContext

func (*Create_server_auditContext) GetFilepath

func (s *Create_server_auditContext) GetFilepath() antlr.Token

func (*Create_server_auditContext) GetMax_files

func (s *Create_server_auditContext) GetMax_files() antlr.Token

func (*Create_server_auditContext) GetMax_rollover_files

func (s *Create_server_auditContext) GetMax_rollover_files() antlr.Token

func (*Create_server_auditContext) GetNew_audit_name

func (s *Create_server_auditContext) GetNew_audit_name() IIdContext

func (*Create_server_auditContext) GetParser

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

func (*Create_server_auditContext) GetQueue_delay

func (s *Create_server_auditContext) GetQueue_delay() antlr.Token

func (*Create_server_auditContext) GetRuleContext

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

func (*Create_server_auditContext) Id

func (*Create_server_auditContext) IsCreate_server_auditContext

func (*Create_server_auditContext) IsCreate_server_auditContext()

func (*Create_server_auditContext) LESS

func (*Create_server_auditContext) LR_BRACKET

func (*Create_server_auditContext) MAXSIZE

func (*Create_server_auditContext) MAX_FILES

func (*Create_server_auditContext) MAX_ROLLOVER_FILES

func (s *Create_server_auditContext) MAX_ROLLOVER_FILES(i int) antlr.TerminalNode

func (*Create_server_auditContext) MB

func (*Create_server_auditContext) MODIFY

func (*Create_server_auditContext) NAME

func (*Create_server_auditContext) NOT

func (*Create_server_auditContext) OFF

func (*Create_server_auditContext) ON

func (*Create_server_auditContext) ON_FAILURE

func (*Create_server_auditContext) OR

func (*Create_server_auditContext) QUEUE_DELAY

func (*Create_server_auditContext) REMOVE

func (*Create_server_auditContext) RESERVE_DISK_SPACE

func (s *Create_server_auditContext) RESERVE_DISK_SPACE(i int) antlr.TerminalNode

func (*Create_server_auditContext) RR_BRACKET

func (*Create_server_auditContext) SECURITY_LOG

func (s *Create_server_auditContext) SECURITY_LOG() antlr.TerminalNode

func (*Create_server_auditContext) SERVER

func (*Create_server_auditContext) SHUTDOWN

func (*Create_server_auditContext) STATE

func (*Create_server_auditContext) STRING

func (*Create_server_auditContext) SetAudit_guid

func (s *Create_server_auditContext) SetAudit_guid(v IIdContext)

func (*Create_server_auditContext) SetAudit_name

func (s *Create_server_auditContext) SetAudit_name(v IIdContext)

func (*Create_server_auditContext) SetEvent_field_name

func (s *Create_server_auditContext) SetEvent_field_name(v IIdContext)

func (*Create_server_auditContext) SetFilepath

func (s *Create_server_auditContext) SetFilepath(v antlr.Token)

func (*Create_server_auditContext) SetMax_files

func (s *Create_server_auditContext) SetMax_files(v antlr.Token)

func (*Create_server_auditContext) SetMax_rollover_files

func (s *Create_server_auditContext) SetMax_rollover_files(v antlr.Token)

func (*Create_server_auditContext) SetNew_audit_name

func (s *Create_server_auditContext) SetNew_audit_name(v IIdContext)

func (*Create_server_auditContext) SetQueue_delay

func (s *Create_server_auditContext) SetQueue_delay(v antlr.Token)

func (*Create_server_auditContext) TB

func (*Create_server_auditContext) TO

func (*Create_server_auditContext) ToStringTree

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

func (*Create_server_auditContext) UNLIMITED

func (*Create_server_auditContext) WHERE

func (*Create_server_auditContext) WITH

type Create_server_audit_specificationContext

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

func NewCreate_server_audit_specificationContext

func NewCreate_server_audit_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_server_audit_specificationContext

func NewEmptyCreate_server_audit_specificationContext

func NewEmptyCreate_server_audit_specificationContext() *Create_server_audit_specificationContext

func (*Create_server_audit_specificationContext) ADD

func (*Create_server_audit_specificationContext) AUDIT

func (*Create_server_audit_specificationContext) AllADD

func (*Create_server_audit_specificationContext) AllAUDIT

func (*Create_server_audit_specificationContext) AllId

func (*Create_server_audit_specificationContext) AllLR_BRACKET

func (*Create_server_audit_specificationContext) AllRR_BRACKET

func (*Create_server_audit_specificationContext) AllSERVER

func (*Create_server_audit_specificationContext) CREATE

func (*Create_server_audit_specificationContext) EQUAL

func (*Create_server_audit_specificationContext) EnterRule

func (*Create_server_audit_specificationContext) ExitRule

func (*Create_server_audit_specificationContext) FOR

func (*Create_server_audit_specificationContext) GetAudit_action_group_name

func (s *Create_server_audit_specificationContext) GetAudit_action_group_name() IIdContext

func (*Create_server_audit_specificationContext) GetAudit_name

func (*Create_server_audit_specificationContext) GetAudit_specification_name

func (s *Create_server_audit_specificationContext) GetAudit_specification_name() IIdContext

func (*Create_server_audit_specificationContext) GetParser

func (*Create_server_audit_specificationContext) GetRuleContext

func (*Create_server_audit_specificationContext) Id

func (*Create_server_audit_specificationContext) IsCreate_server_audit_specificationContext

func (*Create_server_audit_specificationContext) IsCreate_server_audit_specificationContext()

func (*Create_server_audit_specificationContext) LR_BRACKET

func (*Create_server_audit_specificationContext) OFF

func (*Create_server_audit_specificationContext) ON

func (*Create_server_audit_specificationContext) RR_BRACKET

func (*Create_server_audit_specificationContext) SERVER

func (*Create_server_audit_specificationContext) SPECIFICATION

func (*Create_server_audit_specificationContext) STATE

func (*Create_server_audit_specificationContext) SetAudit_action_group_name

func (s *Create_server_audit_specificationContext) SetAudit_action_group_name(v IIdContext)

func (*Create_server_audit_specificationContext) SetAudit_name

func (*Create_server_audit_specificationContext) SetAudit_specification_name

func (s *Create_server_audit_specificationContext) SetAudit_specification_name(v IIdContext)

func (*Create_server_audit_specificationContext) ToStringTree

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

func (*Create_server_audit_specificationContext) WITH

type Create_server_roleContext

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

func NewCreate_server_roleContext

func NewCreate_server_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_server_roleContext

func NewEmptyCreate_server_roleContext

func NewEmptyCreate_server_roleContext() *Create_server_roleContext

func (*Create_server_roleContext) AUTHORIZATION

func (s *Create_server_roleContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_server_roleContext) AllId

func (*Create_server_roleContext) CREATE

func (*Create_server_roleContext) EnterRule

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

func (*Create_server_roleContext) ExitRule

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

func (*Create_server_roleContext) GetParser

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

func (*Create_server_roleContext) GetRuleContext

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

func (*Create_server_roleContext) GetServer_principal

func (s *Create_server_roleContext) GetServer_principal() IIdContext

func (*Create_server_roleContext) GetServer_role

func (s *Create_server_roleContext) GetServer_role() IIdContext

func (*Create_server_roleContext) Id

func (*Create_server_roleContext) IsCreate_server_roleContext

func (*Create_server_roleContext) IsCreate_server_roleContext()

func (*Create_server_roleContext) ROLE

func (*Create_server_roleContext) SERVER

func (*Create_server_roleContext) SetServer_principal

func (s *Create_server_roleContext) SetServer_principal(v IIdContext)

func (*Create_server_roleContext) SetServer_role

func (s *Create_server_roleContext) SetServer_role(v IIdContext)

func (*Create_server_roleContext) ToStringTree

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

type Create_serviceContext

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

func NewCreate_serviceContext

func NewCreate_serviceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_serviceContext

func NewEmptyCreate_serviceContext

func NewEmptyCreate_serviceContext() *Create_serviceContext

func (*Create_serviceContext) AUTHORIZATION

func (s *Create_serviceContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_serviceContext) AllCOMMA

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

func (*Create_serviceContext) AllDEFAULT

func (s *Create_serviceContext) AllDEFAULT() []antlr.TerminalNode

func (*Create_serviceContext) AllId

func (s *Create_serviceContext) AllId() []IIdContext

func (*Create_serviceContext) COMMA

func (*Create_serviceContext) CREATE

func (*Create_serviceContext) DEFAULT

func (*Create_serviceContext) DOT

func (*Create_serviceContext) EnterRule

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

func (*Create_serviceContext) ExitRule

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

func (*Create_serviceContext) GetCreate_service_name

func (s *Create_serviceContext) GetCreate_service_name() IIdContext

func (*Create_serviceContext) GetOwner_name

func (s *Create_serviceContext) GetOwner_name() IIdContext

func (*Create_serviceContext) GetParser

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

func (*Create_serviceContext) GetQueue_name

func (s *Create_serviceContext) GetQueue_name() IIdContext

func (*Create_serviceContext) GetRuleContext

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

func (*Create_serviceContext) GetSchema_name

func (s *Create_serviceContext) GetSchema_name() IIdContext

func (*Create_serviceContext) Id

func (*Create_serviceContext) IsCreate_serviceContext

func (*Create_serviceContext) IsCreate_serviceContext()

func (*Create_serviceContext) LR_BRACKET

func (s *Create_serviceContext) LR_BRACKET() antlr.TerminalNode

func (*Create_serviceContext) ON

func (*Create_serviceContext) QUEUE

func (*Create_serviceContext) RR_BRACKET

func (s *Create_serviceContext) RR_BRACKET() antlr.TerminalNode

func (*Create_serviceContext) SERVICE

func (*Create_serviceContext) SetCreate_service_name

func (s *Create_serviceContext) SetCreate_service_name(v IIdContext)

func (*Create_serviceContext) SetOwner_name

func (s *Create_serviceContext) SetOwner_name(v IIdContext)

func (*Create_serviceContext) SetQueue_name

func (s *Create_serviceContext) SetQueue_name(v IIdContext)

func (*Create_serviceContext) SetSchema_name

func (s *Create_serviceContext) SetSchema_name(v IIdContext)

func (*Create_serviceContext) ToStringTree

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

type Create_statisticsContext

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

func NewCreate_statisticsContext

func NewCreate_statisticsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_statisticsContext

func NewEmptyCreate_statisticsContext

func NewEmptyCreate_statisticsContext() *Create_statisticsContext

func (*Create_statisticsContext) AllCOMMA

func (*Create_statisticsContext) COMMA

func (*Create_statisticsContext) CREATE

func (*Create_statisticsContext) Column_name_list

func (s *Create_statisticsContext) Column_name_list() IColumn_name_listContext

func (*Create_statisticsContext) DECIMAL

func (*Create_statisticsContext) EQUAL

func (*Create_statisticsContext) EnterRule

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

func (*Create_statisticsContext) ExitRule

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

func (*Create_statisticsContext) FULLSCAN

func (*Create_statisticsContext) GetParser

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

func (*Create_statisticsContext) GetRuleContext

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

func (*Create_statisticsContext) INCREMENTAL

func (s *Create_statisticsContext) INCREMENTAL() antlr.TerminalNode

func (*Create_statisticsContext) Id

func (*Create_statisticsContext) IsCreate_statisticsContext

func (*Create_statisticsContext) IsCreate_statisticsContext()

func (*Create_statisticsContext) LR_BRACKET

func (*Create_statisticsContext) NORECOMPUTE

func (s *Create_statisticsContext) NORECOMPUTE() antlr.TerminalNode

func (*Create_statisticsContext) ON

func (*Create_statisticsContext) On_off

func (*Create_statisticsContext) PERCENT

func (*Create_statisticsContext) ROWS

func (*Create_statisticsContext) RR_BRACKET

func (*Create_statisticsContext) SAMPLE

func (*Create_statisticsContext) SEMI

func (*Create_statisticsContext) STATISTICS

func (*Create_statisticsContext) STATS_STREAM

func (s *Create_statisticsContext) STATS_STREAM() antlr.TerminalNode

func (*Create_statisticsContext) Table_name_with_hint

func (s *Create_statisticsContext) Table_name_with_hint() ITable_name_with_hintContext

func (*Create_statisticsContext) ToStringTree

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

func (*Create_statisticsContext) WITH

type Create_symmetric_keyContext

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

func NewCreate_symmetric_keyContext

func NewCreate_symmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_symmetric_keyContext

func NewEmptyCreate_symmetric_keyContext

func NewEmptyCreate_symmetric_keyContext() *Create_symmetric_keyContext

func (*Create_symmetric_keyContext) AES_128

func (*Create_symmetric_keyContext) AES_192

func (*Create_symmetric_keyContext) AES_256

func (*Create_symmetric_keyContext) ALGORITHM

func (*Create_symmetric_keyContext) ALTER

func (*Create_symmetric_keyContext) ASYMMETRIC

func (*Create_symmetric_keyContext) AUTHORIZATION

func (s *Create_symmetric_keyContext) AUTHORIZATION() antlr.TerminalNode

func (*Create_symmetric_keyContext) AllId

func (*Create_symmetric_keyContext) AllKEY

func (*Create_symmetric_keyContext) AllSYMMETRIC

func (s *Create_symmetric_keyContext) AllSYMMETRIC() []antlr.TerminalNode

func (*Create_symmetric_keyContext) BY

func (*Create_symmetric_keyContext) CERTIFICATE

func (*Create_symmetric_keyContext) CREATE_NEW

func (*Create_symmetric_keyContext) CREATION_DISPOSITION

func (s *Create_symmetric_keyContext) CREATION_DISPOSITION() antlr.TerminalNode

func (*Create_symmetric_keyContext) DES

func (*Create_symmetric_keyContext) DESX

func (*Create_symmetric_keyContext) ENCRYPTION

func (*Create_symmetric_keyContext) EQUAL

func (*Create_symmetric_keyContext) EnterRule

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

func (*Create_symmetric_keyContext) ExitRule

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

func (*Create_symmetric_keyContext) FROM

func (*Create_symmetric_keyContext) GetAsym_key_name

func (s *Create_symmetric_keyContext) GetAsym_key_name() IIdContext

func (*Create_symmetric_keyContext) GetCertificate_name

func (s *Create_symmetric_keyContext) GetCertificate_name() IIdContext

func (*Create_symmetric_keyContext) GetIdentity_phrase

func (s *Create_symmetric_keyContext) GetIdentity_phrase() antlr.Token

func (*Create_symmetric_keyContext) GetKey_name

func (s *Create_symmetric_keyContext) GetKey_name() IIdContext

func (*Create_symmetric_keyContext) GetKey_pass_phrase

func (s *Create_symmetric_keyContext) GetKey_pass_phrase() antlr.Token

func (*Create_symmetric_keyContext) GetOwner_name

func (s *Create_symmetric_keyContext) GetOwner_name() IIdContext

func (*Create_symmetric_keyContext) GetParser

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

func (*Create_symmetric_keyContext) GetPassword

func (s *Create_symmetric_keyContext) GetPassword() antlr.Token

func (*Create_symmetric_keyContext) GetProvider_key_name

func (s *Create_symmetric_keyContext) GetProvider_key_name() antlr.Token

func (*Create_symmetric_keyContext) GetProvider_name

func (s *Create_symmetric_keyContext) GetProvider_name() IIdContext

func (*Create_symmetric_keyContext) GetRuleContext

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

func (*Create_symmetric_keyContext) GetSymmetric_key_name

func (s *Create_symmetric_keyContext) GetSymmetric_key_name() IIdContext

func (*Create_symmetric_keyContext) IDENTITY_VALUE

func (s *Create_symmetric_keyContext) IDENTITY_VALUE() antlr.TerminalNode

func (*Create_symmetric_keyContext) Id

func (*Create_symmetric_keyContext) IsCreate_symmetric_keyContext

func (*Create_symmetric_keyContext) IsCreate_symmetric_keyContext()

func (*Create_symmetric_keyContext) KEY

func (*Create_symmetric_keyContext) KEY_SOURCE

func (*Create_symmetric_keyContext) OPEN_EXISTING

func (s *Create_symmetric_keyContext) OPEN_EXISTING() antlr.TerminalNode

func (*Create_symmetric_keyContext) PASSWORD

func (*Create_symmetric_keyContext) PROVIDER

func (*Create_symmetric_keyContext) PROVIDER_KEY_NAME

func (s *Create_symmetric_keyContext) PROVIDER_KEY_NAME() antlr.TerminalNode

func (*Create_symmetric_keyContext) RC2

func (*Create_symmetric_keyContext) RC4

func (*Create_symmetric_keyContext) RC4_128

func (*Create_symmetric_keyContext) STRING

func (*Create_symmetric_keyContext) SYMMETRIC

func (*Create_symmetric_keyContext) SetAsym_key_name

func (s *Create_symmetric_keyContext) SetAsym_key_name(v IIdContext)

func (*Create_symmetric_keyContext) SetCertificate_name

func (s *Create_symmetric_keyContext) SetCertificate_name(v IIdContext)

func (*Create_symmetric_keyContext) SetIdentity_phrase

func (s *Create_symmetric_keyContext) SetIdentity_phrase(v antlr.Token)

func (*Create_symmetric_keyContext) SetKey_name

func (s *Create_symmetric_keyContext) SetKey_name(v IIdContext)

func (*Create_symmetric_keyContext) SetKey_pass_phrase

func (s *Create_symmetric_keyContext) SetKey_pass_phrase(v antlr.Token)

func (*Create_symmetric_keyContext) SetOwner_name

func (s *Create_symmetric_keyContext) SetOwner_name(v IIdContext)

func (*Create_symmetric_keyContext) SetPassword

func (s *Create_symmetric_keyContext) SetPassword(v antlr.Token)

func (*Create_symmetric_keyContext) SetProvider_key_name

func (s *Create_symmetric_keyContext) SetProvider_key_name(v antlr.Token)

func (*Create_symmetric_keyContext) SetProvider_name

func (s *Create_symmetric_keyContext) SetProvider_name(v IIdContext)

func (*Create_symmetric_keyContext) SetSymmetric_key_name

func (s *Create_symmetric_keyContext) SetSymmetric_key_name(v IIdContext)

func (*Create_symmetric_keyContext) TRIPLE_DES

func (*Create_symmetric_keyContext) TRIPLE_DES_3KEY

func (s *Create_symmetric_keyContext) TRIPLE_DES_3KEY() antlr.TerminalNode

func (*Create_symmetric_keyContext) ToStringTree

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

func (*Create_symmetric_keyContext) WITH

type Create_synonymContext

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

func NewCreate_synonymContext

func NewCreate_synonymContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_synonymContext

func NewEmptyCreate_synonymContext

func NewEmptyCreate_synonymContext() *Create_synonymContext

func (*Create_synonymContext) AllDOT

func (*Create_synonymContext) AllId

func (s *Create_synonymContext) AllId() []IIdContext

func (*Create_synonymContext) CREATE

func (*Create_synonymContext) DOT

func (*Create_synonymContext) EnterRule

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

func (*Create_synonymContext) ExitRule

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

func (*Create_synonymContext) FOR

func (*Create_synonymContext) GetDatabase_name

func (s *Create_synonymContext) GetDatabase_name() IIdContext

func (*Create_synonymContext) GetDatabase_or_schema2

func (s *Create_synonymContext) GetDatabase_or_schema2() IIdContext

func (*Create_synonymContext) GetObject_name

func (s *Create_synonymContext) GetObject_name() IIdContext

func (*Create_synonymContext) GetParser

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

func (*Create_synonymContext) GetRuleContext

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

func (*Create_synonymContext) GetSchema_id_2_or_object_name

func (s *Create_synonymContext) GetSchema_id_2_or_object_name() IIdContext

func (*Create_synonymContext) GetSchema_name_1

func (s *Create_synonymContext) GetSchema_name_1() IIdContext

func (*Create_synonymContext) GetSchema_name_2

func (s *Create_synonymContext) GetSchema_name_2() IIdContext

func (*Create_synonymContext) GetServer_name

func (s *Create_synonymContext) GetServer_name() IIdContext

func (*Create_synonymContext) GetSynonym_name

func (s *Create_synonymContext) GetSynonym_name() IIdContext

func (*Create_synonymContext) Id

func (*Create_synonymContext) IsCreate_synonymContext

func (*Create_synonymContext) IsCreate_synonymContext()

func (*Create_synonymContext) SYNONYM

func (*Create_synonymContext) SetDatabase_name

func (s *Create_synonymContext) SetDatabase_name(v IIdContext)

func (*Create_synonymContext) SetDatabase_or_schema2

func (s *Create_synonymContext) SetDatabase_or_schema2(v IIdContext)

func (*Create_synonymContext) SetObject_name

func (s *Create_synonymContext) SetObject_name(v IIdContext)

func (*Create_synonymContext) SetSchema_id_2_or_object_name

func (s *Create_synonymContext) SetSchema_id_2_or_object_name(v IIdContext)

func (*Create_synonymContext) SetSchema_name_1

func (s *Create_synonymContext) SetSchema_name_1(v IIdContext)

func (*Create_synonymContext) SetSchema_name_2

func (s *Create_synonymContext) SetSchema_name_2(v IIdContext)

func (*Create_synonymContext) SetServer_name

func (s *Create_synonymContext) SetServer_name(v IIdContext)

func (*Create_synonymContext) SetSynonym_name

func (s *Create_synonymContext) SetSynonym_name(v IIdContext)

func (*Create_synonymContext) ToStringTree

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

type Create_tableContext

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

func NewCreate_tableContext

func NewCreate_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_tableContext

func NewEmptyCreate_tableContext

func NewEmptyCreate_tableContext() *Create_tableContext

func (*Create_tableContext) AllDEFAULT

func (s *Create_tableContext) AllDEFAULT() []antlr.TerminalNode

func (*Create_tableContext) AllId

func (s *Create_tableContext) AllId() []IIdContext

func (*Create_tableContext) AllTable_options

func (s *Create_tableContext) AllTable_options() []ITable_optionsContext

func (*Create_tableContext) COMMA

func (*Create_tableContext) CREATE

func (*Create_tableContext) Column_def_table_constraints

func (s *Create_tableContext) Column_def_table_constraints() IColumn_def_table_constraintsContext

func (*Create_tableContext) DEFAULT

func (s *Create_tableContext) DEFAULT(i int) antlr.TerminalNode

func (*Create_tableContext) EnterRule

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

func (*Create_tableContext) ExitRule

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

func (*Create_tableContext) GetParser

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

func (*Create_tableContext) GetRuleContext

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

func (*Create_tableContext) Id

func (*Create_tableContext) IsCreate_tableContext

func (*Create_tableContext) IsCreate_tableContext()

func (*Create_tableContext) LOCK

func (*Create_tableContext) LR_BRACKET

func (s *Create_tableContext) LR_BRACKET() antlr.TerminalNode

func (*Create_tableContext) ON

func (*Create_tableContext) RR_BRACKET

func (s *Create_tableContext) RR_BRACKET() antlr.TerminalNode

func (*Create_tableContext) SEMI

func (*Create_tableContext) Simple_id

func (s *Create_tableContext) Simple_id() ISimple_idContext

func (*Create_tableContext) TABLE

func (*Create_tableContext) TEXTIMAGE_ON

func (s *Create_tableContext) TEXTIMAGE_ON() antlr.TerminalNode

func (*Create_tableContext) Table_name

func (s *Create_tableContext) Table_name() ITable_nameContext

func (*Create_tableContext) Table_options

func (s *Create_tableContext) Table_options(i int) ITable_optionsContext

func (*Create_tableContext) ToStringTree

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

type Create_typeContext

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

func NewCreate_typeContext

func NewCreate_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_typeContext

func NewEmptyCreate_typeContext

func NewEmptyCreate_typeContext() *Create_typeContext

func (*Create_typeContext) AS

func (*Create_typeContext) CREATE

func (*Create_typeContext) Column_def_table_constraints

func (s *Create_typeContext) Column_def_table_constraints() IColumn_def_table_constraintsContext

func (*Create_typeContext) Data_type

func (s *Create_typeContext) Data_type() IData_typeContext

func (*Create_typeContext) Default_value

func (s *Create_typeContext) Default_value() IDefault_valueContext

func (*Create_typeContext) EnterRule

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

func (*Create_typeContext) ExitRule

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

func (*Create_typeContext) FROM

func (*Create_typeContext) GetName

func (*Create_typeContext) GetParser

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

func (*Create_typeContext) GetRuleContext

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

func (*Create_typeContext) IsCreate_typeContext

func (*Create_typeContext) IsCreate_typeContext()

func (*Create_typeContext) LR_BRACKET

func (s *Create_typeContext) LR_BRACKET() antlr.TerminalNode

func (*Create_typeContext) RR_BRACKET

func (s *Create_typeContext) RR_BRACKET() antlr.TerminalNode

func (*Create_typeContext) SetName

func (*Create_typeContext) Simple_name

func (s *Create_typeContext) Simple_name() ISimple_nameContext

func (*Create_typeContext) TABLE

func (*Create_typeContext) TYPE

func (*Create_typeContext) ToStringTree

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

type Create_userContext

type Create_userContext struct {
	*antlr.BaseParserRuleContext

	Azure_Active_Directory_principal IIdContext
	// contains filtered or unexported fields
}

func NewCreate_userContext

func NewCreate_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_userContext

func NewEmptyCreate_userContext

func NewEmptyCreate_userContext() *Create_userContext

func (*Create_userContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS

func (s *Create_userContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS(i int) antlr.TerminalNode

func (*Create_userContext) ASYMMETRIC

func (s *Create_userContext) ASYMMETRIC() antlr.TerminalNode

func (*Create_userContext) AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS

func (s *Create_userContext) AllALLOW_ENCRYPTED_VALUE_MODIFICATIONS() []antlr.TerminalNode

func (*Create_userContext) AllBINARY

func (s *Create_userContext) AllBINARY() []antlr.TerminalNode

func (*Create_userContext) AllCOMMA

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

func (*Create_userContext) AllDECIMAL

func (s *Create_userContext) AllDECIMAL() []antlr.TerminalNode

func (*Create_userContext) AllDEFAULT_LANGUAGE

func (s *Create_userContext) AllDEFAULT_LANGUAGE() []antlr.TerminalNode

func (*Create_userContext) AllDEFAULT_SCHEMA

func (s *Create_userContext) AllDEFAULT_SCHEMA() []antlr.TerminalNode

func (*Create_userContext) AllEQUAL

func (s *Create_userContext) AllEQUAL() []antlr.TerminalNode

func (*Create_userContext) AllId

func (s *Create_userContext) AllId() []IIdContext

func (*Create_userContext) AllNONE

func (s *Create_userContext) AllNONE() []antlr.TerminalNode

func (*Create_userContext) AllOFF

func (s *Create_userContext) AllOFF() []antlr.TerminalNode

func (*Create_userContext) AllON

func (s *Create_userContext) AllON() []antlr.TerminalNode

func (*Create_userContext) AllSID

func (s *Create_userContext) AllSID() []antlr.TerminalNode

func (*Create_userContext) BINARY

func (*Create_userContext) CERTIFICATE

func (s *Create_userContext) CERTIFICATE() antlr.TerminalNode

func (*Create_userContext) COMMA

func (*Create_userContext) CREATE

func (*Create_userContext) DECIMAL

func (s *Create_userContext) DECIMAL(i int) antlr.TerminalNode

func (*Create_userContext) DEFAULT_LANGUAGE

func (s *Create_userContext) DEFAULT_LANGUAGE(i int) antlr.TerminalNode

func (*Create_userContext) DEFAULT_SCHEMA

func (s *Create_userContext) DEFAULT_SCHEMA(i int) antlr.TerminalNode

func (*Create_userContext) EQUAL

func (*Create_userContext) EXTERNAL

func (s *Create_userContext) EXTERNAL() antlr.TerminalNode

func (*Create_userContext) EnterRule

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

func (*Create_userContext) ExitRule

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

func (*Create_userContext) FOR

func (*Create_userContext) FROM

func (*Create_userContext) GetAsym_key_name

func (s *Create_userContext) GetAsym_key_name() IIdContext

func (*Create_userContext) GetAzure_Active_Directory_principal

func (s *Create_userContext) GetAzure_Active_Directory_principal() IIdContext

func (*Create_userContext) GetCert_name

func (s *Create_userContext) GetCert_name() IIdContext

func (*Create_userContext) GetLanguage_name_or_alias

func (s *Create_userContext) GetLanguage_name_or_alias() IIdContext

func (*Create_userContext) GetLogin_name

func (s *Create_userContext) GetLogin_name() IIdContext

func (*Create_userContext) GetParser

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

func (*Create_userContext) GetPassword

func (s *Create_userContext) GetPassword() antlr.Token

func (*Create_userContext) GetRuleContext

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

func (*Create_userContext) GetSchema_name

func (s *Create_userContext) GetSchema_name() IIdContext

func (*Create_userContext) GetUser_name

func (s *Create_userContext) GetUser_name() IIdContext

func (*Create_userContext) GetWindows_principal

func (s *Create_userContext) GetWindows_principal() IIdContext

func (*Create_userContext) Id

func (*Create_userContext) IsCreate_userContext

func (*Create_userContext) IsCreate_userContext()

func (*Create_userContext) KEY

func (*Create_userContext) LOGIN

func (*Create_userContext) NONE

func (*Create_userContext) OFF

func (*Create_userContext) ON

func (*Create_userContext) PASSWORD

func (s *Create_userContext) PASSWORD() antlr.TerminalNode

func (*Create_userContext) PROVIDER

func (s *Create_userContext) PROVIDER() antlr.TerminalNode

func (*Create_userContext) SID

func (*Create_userContext) STRING

func (*Create_userContext) SetAsym_key_name

func (s *Create_userContext) SetAsym_key_name(v IIdContext)

func (*Create_userContext) SetAzure_Active_Directory_principal

func (s *Create_userContext) SetAzure_Active_Directory_principal(v IIdContext)

func (*Create_userContext) SetCert_name

func (s *Create_userContext) SetCert_name(v IIdContext)

func (*Create_userContext) SetLanguage_name_or_alias

func (s *Create_userContext) SetLanguage_name_or_alias(v IIdContext)

func (*Create_userContext) SetLogin_name

func (s *Create_userContext) SetLogin_name(v IIdContext)

func (*Create_userContext) SetPassword

func (s *Create_userContext) SetPassword(v antlr.Token)

func (*Create_userContext) SetSchema_name

func (s *Create_userContext) SetSchema_name(v IIdContext)

func (*Create_userContext) SetUser_name

func (s *Create_userContext) SetUser_name(v IIdContext)

func (*Create_userContext) SetWindows_principal

func (s *Create_userContext) SetWindows_principal(v IIdContext)

func (*Create_userContext) ToStringTree

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

func (*Create_userContext) USER

func (*Create_userContext) WITH

func (*Create_userContext) WITHOUT

func (s *Create_userContext) WITHOUT() antlr.TerminalNode

type Create_user_azure_sql_dwContext

type Create_user_azure_sql_dwContext struct {
	*antlr.BaseParserRuleContext

	Azure_Active_Directory_principal IIdContext
	// contains filtered or unexported fields
}

func NewCreate_user_azure_sql_dwContext

func NewCreate_user_azure_sql_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_user_azure_sql_dwContext

func NewEmptyCreate_user_azure_sql_dwContext

func NewEmptyCreate_user_azure_sql_dwContext() *Create_user_azure_sql_dwContext

func (*Create_user_azure_sql_dwContext) AllId

func (*Create_user_azure_sql_dwContext) CREATE

func (*Create_user_azure_sql_dwContext) DEFAULT_SCHEMA

func (*Create_user_azure_sql_dwContext) EQUAL

func (*Create_user_azure_sql_dwContext) EXTERNAL

func (*Create_user_azure_sql_dwContext) EnterRule

func (*Create_user_azure_sql_dwContext) ExitRule

func (*Create_user_azure_sql_dwContext) FOR

func (*Create_user_azure_sql_dwContext) FROM

func (*Create_user_azure_sql_dwContext) GetAzure_Active_Directory_principal

func (s *Create_user_azure_sql_dwContext) GetAzure_Active_Directory_principal() IIdContext

func (*Create_user_azure_sql_dwContext) GetLogin_name

func (s *Create_user_azure_sql_dwContext) GetLogin_name() IIdContext

func (*Create_user_azure_sql_dwContext) GetParser

func (*Create_user_azure_sql_dwContext) GetRuleContext

func (*Create_user_azure_sql_dwContext) GetSchema_name

func (s *Create_user_azure_sql_dwContext) GetSchema_name() IIdContext

func (*Create_user_azure_sql_dwContext) GetUser_name

func (s *Create_user_azure_sql_dwContext) GetUser_name() IIdContext

func (*Create_user_azure_sql_dwContext) Id

func (*Create_user_azure_sql_dwContext) IsCreate_user_azure_sql_dwContext

func (*Create_user_azure_sql_dwContext) IsCreate_user_azure_sql_dwContext()

func (*Create_user_azure_sql_dwContext) LOGIN

func (*Create_user_azure_sql_dwContext) PROVIDER

func (*Create_user_azure_sql_dwContext) SetAzure_Active_Directory_principal

func (s *Create_user_azure_sql_dwContext) SetAzure_Active_Directory_principal(v IIdContext)

func (*Create_user_azure_sql_dwContext) SetLogin_name

func (s *Create_user_azure_sql_dwContext) SetLogin_name(v IIdContext)

func (*Create_user_azure_sql_dwContext) SetSchema_name

func (s *Create_user_azure_sql_dwContext) SetSchema_name(v IIdContext)

func (*Create_user_azure_sql_dwContext) SetUser_name

func (s *Create_user_azure_sql_dwContext) SetUser_name(v IIdContext)

func (*Create_user_azure_sql_dwContext) ToStringTree

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

func (*Create_user_azure_sql_dwContext) USER

func (*Create_user_azure_sql_dwContext) WITH

func (*Create_user_azure_sql_dwContext) WITHOUT

type Create_viewContext

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

func NewCreate_viewContext

func NewCreate_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_viewContext

func NewEmptyCreate_viewContext

func NewEmptyCreate_viewContext() *Create_viewContext

func (*Create_viewContext) AS

func (*Create_viewContext) AllCOMMA

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

func (*Create_viewContext) AllView_attribute

func (s *Create_viewContext) AllView_attribute() []IView_attributeContext

func (*Create_viewContext) AllWITH

func (s *Create_viewContext) AllWITH() []antlr.TerminalNode

func (*Create_viewContext) CHECK

func (*Create_viewContext) COMMA

func (*Create_viewContext) CREATE

func (*Create_viewContext) Column_name_list

func (s *Create_viewContext) Column_name_list() IColumn_name_listContext

func (*Create_viewContext) EnterRule

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

func (*Create_viewContext) ExitRule

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

func (*Create_viewContext) GetParser

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

func (*Create_viewContext) GetRuleContext

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

func (*Create_viewContext) IsCreate_viewContext

func (*Create_viewContext) IsCreate_viewContext()

func (*Create_viewContext) LR_BRACKET

func (s *Create_viewContext) LR_BRACKET() antlr.TerminalNode

func (*Create_viewContext) OPTION

func (*Create_viewContext) RR_BRACKET

func (s *Create_viewContext) RR_BRACKET() antlr.TerminalNode

func (*Create_viewContext) SEMI

func (*Create_viewContext) Select_statement

func (s *Create_viewContext) Select_statement() ISelect_statementContext

func (*Create_viewContext) Simple_name

func (s *Create_viewContext) Simple_name() ISimple_nameContext

func (*Create_viewContext) ToStringTree

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

func (*Create_viewContext) VIEW

func (*Create_viewContext) View_attribute

func (s *Create_viewContext) View_attribute(i int) IView_attributeContext

func (*Create_viewContext) WITH

type Create_workload_groupContext

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

func NewCreate_workload_groupContext

func NewCreate_workload_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_workload_groupContext

func NewEmptyCreate_workload_groupContext

func NewEmptyCreate_workload_groupContext() *Create_workload_groupContext

func (*Create_workload_groupContext) AllCOMMA

func (*Create_workload_groupContext) AllDECIMAL

func (*Create_workload_groupContext) AllDEFAULT_DOUBLE_QUOTE

func (s *Create_workload_groupContext) AllDEFAULT_DOUBLE_QUOTE() []antlr.TerminalNode

func (*Create_workload_groupContext) AllEQUAL

func (*Create_workload_groupContext) AllGROUP_MAX_REQUESTS

func (s *Create_workload_groupContext) AllGROUP_MAX_REQUESTS() []antlr.TerminalNode

func (*Create_workload_groupContext) AllHIGH

func (*Create_workload_groupContext) AllIMPORTANCE

func (s *Create_workload_groupContext) AllIMPORTANCE() []antlr.TerminalNode

func (*Create_workload_groupContext) AllId

func (*Create_workload_groupContext) AllLOW

func (*Create_workload_groupContext) AllMAX_DOP

func (*Create_workload_groupContext) AllMEDIUM

func (*Create_workload_groupContext) AllREQUEST_MAX_CPU_TIME_SEC

func (s *Create_workload_groupContext) AllREQUEST_MAX_CPU_TIME_SEC() []antlr.TerminalNode

func (*Create_workload_groupContext) AllREQUEST_MAX_MEMORY_GRANT_PERCENT

func (s *Create_workload_groupContext) AllREQUEST_MAX_MEMORY_GRANT_PERCENT() []antlr.TerminalNode

func (*Create_workload_groupContext) AllREQUEST_MEMORY_GRANT_TIMEOUT_SEC

func (s *Create_workload_groupContext) AllREQUEST_MEMORY_GRANT_TIMEOUT_SEC() []antlr.TerminalNode

func (*Create_workload_groupContext) COMMA

func (*Create_workload_groupContext) CREATE

func (*Create_workload_groupContext) DECIMAL

func (*Create_workload_groupContext) DEFAULT_DOUBLE_QUOTE

func (s *Create_workload_groupContext) DEFAULT_DOUBLE_QUOTE(i int) antlr.TerminalNode

func (*Create_workload_groupContext) EQUAL

func (*Create_workload_groupContext) EXTERNAL

func (*Create_workload_groupContext) EnterRule

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

func (*Create_workload_groupContext) ExitRule

func (*Create_workload_groupContext) GROUP

func (*Create_workload_groupContext) GROUP_MAX_REQUESTS

func (s *Create_workload_groupContext) GROUP_MAX_REQUESTS(i int) antlr.TerminalNode

func (*Create_workload_groupContext) GetExternal_pool_name

func (s *Create_workload_groupContext) GetExternal_pool_name() IIdContext

func (*Create_workload_groupContext) GetGroup_max_requests

func (s *Create_workload_groupContext) GetGroup_max_requests() antlr.Token

func (*Create_workload_groupContext) GetMax_dop

func (s *Create_workload_groupContext) GetMax_dop() antlr.Token

func (*Create_workload_groupContext) GetParser

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

func (*Create_workload_groupContext) GetRequest_max_cpu_time_sec

func (s *Create_workload_groupContext) GetRequest_max_cpu_time_sec() antlr.Token

func (*Create_workload_groupContext) GetRequest_max_memory_grant

func (s *Create_workload_groupContext) GetRequest_max_memory_grant() antlr.Token

func (*Create_workload_groupContext) GetRequest_memory_grant_timeout_sec

func (s *Create_workload_groupContext) GetRequest_memory_grant_timeout_sec() antlr.Token

func (*Create_workload_groupContext) GetRuleContext

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

func (*Create_workload_groupContext) GetWorkload_group_group_name

func (s *Create_workload_groupContext) GetWorkload_group_group_name() IIdContext

func (*Create_workload_groupContext) GetWorkload_group_pool_name

func (s *Create_workload_groupContext) GetWorkload_group_pool_name() IIdContext

func (*Create_workload_groupContext) HIGH

func (*Create_workload_groupContext) IMPORTANCE

func (*Create_workload_groupContext) Id

func (*Create_workload_groupContext) IsCreate_workload_groupContext

func (*Create_workload_groupContext) IsCreate_workload_groupContext()

func (*Create_workload_groupContext) LOW

func (*Create_workload_groupContext) LR_BRACKET

func (*Create_workload_groupContext) MAX_DOP

func (*Create_workload_groupContext) MEDIUM

func (*Create_workload_groupContext) REQUEST_MAX_CPU_TIME_SEC

func (s *Create_workload_groupContext) REQUEST_MAX_CPU_TIME_SEC(i int) antlr.TerminalNode

func (*Create_workload_groupContext) REQUEST_MAX_MEMORY_GRANT_PERCENT

func (s *Create_workload_groupContext) REQUEST_MAX_MEMORY_GRANT_PERCENT(i int) antlr.TerminalNode

func (*Create_workload_groupContext) REQUEST_MEMORY_GRANT_TIMEOUT_SEC

func (s *Create_workload_groupContext) REQUEST_MEMORY_GRANT_TIMEOUT_SEC(i int) antlr.TerminalNode

func (*Create_workload_groupContext) RR_BRACKET

func (*Create_workload_groupContext) SetExternal_pool_name

func (s *Create_workload_groupContext) SetExternal_pool_name(v IIdContext)

func (*Create_workload_groupContext) SetGroup_max_requests

func (s *Create_workload_groupContext) SetGroup_max_requests(v antlr.Token)

func (*Create_workload_groupContext) SetMax_dop

func (s *Create_workload_groupContext) SetMax_dop(v antlr.Token)

func (*Create_workload_groupContext) SetRequest_max_cpu_time_sec

func (s *Create_workload_groupContext) SetRequest_max_cpu_time_sec(v antlr.Token)

func (*Create_workload_groupContext) SetRequest_max_memory_grant

func (s *Create_workload_groupContext) SetRequest_max_memory_grant(v antlr.Token)

func (*Create_workload_groupContext) SetRequest_memory_grant_timeout_sec

func (s *Create_workload_groupContext) SetRequest_memory_grant_timeout_sec(v antlr.Token)

func (*Create_workload_groupContext) SetWorkload_group_group_name

func (s *Create_workload_groupContext) SetWorkload_group_group_name(v IIdContext)

func (*Create_workload_groupContext) SetWorkload_group_pool_name

func (s *Create_workload_groupContext) SetWorkload_group_pool_name(v IIdContext)

func (*Create_workload_groupContext) ToStringTree

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

func (*Create_workload_groupContext) USING

func (*Create_workload_groupContext) WITH

func (*Create_workload_groupContext) WORKLOAD

type Create_xml_schema_collectionContext

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

func NewCreate_xml_schema_collectionContext

func NewCreate_xml_schema_collectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_xml_schema_collectionContext

func NewEmptyCreate_xml_schema_collectionContext

func NewEmptyCreate_xml_schema_collectionContext() *Create_xml_schema_collectionContext

func (*Create_xml_schema_collectionContext) AS

func (*Create_xml_schema_collectionContext) AllId

func (*Create_xml_schema_collectionContext) COLLECTION

func (*Create_xml_schema_collectionContext) CREATE

func (*Create_xml_schema_collectionContext) DOT

func (*Create_xml_schema_collectionContext) EnterRule

func (*Create_xml_schema_collectionContext) ExitRule

func (*Create_xml_schema_collectionContext) GetParser

func (*Create_xml_schema_collectionContext) GetRelational_schema

func (s *Create_xml_schema_collectionContext) GetRelational_schema() IIdContext

func (*Create_xml_schema_collectionContext) GetRuleContext

func (*Create_xml_schema_collectionContext) GetSql_identifier

func (s *Create_xml_schema_collectionContext) GetSql_identifier() IIdContext

func (*Create_xml_schema_collectionContext) Id

func (*Create_xml_schema_collectionContext) IsCreate_xml_schema_collectionContext

func (*Create_xml_schema_collectionContext) IsCreate_xml_schema_collectionContext()

func (*Create_xml_schema_collectionContext) LOCAL_ID

func (*Create_xml_schema_collectionContext) SCHEMA

func (*Create_xml_schema_collectionContext) STRING

func (*Create_xml_schema_collectionContext) SetRelational_schema

func (s *Create_xml_schema_collectionContext) SetRelational_schema(v IIdContext)

func (*Create_xml_schema_collectionContext) SetSql_identifier

func (s *Create_xml_schema_collectionContext) SetSql_identifier(v IIdContext)

func (*Create_xml_schema_collectionContext) ToStringTree

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

func (*Create_xml_schema_collectionContext) XML

type Cursor_nameContext

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

func NewCursor_nameContext

func NewCursor_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_nameContext

func NewEmptyCursor_nameContext

func NewEmptyCursor_nameContext() *Cursor_nameContext

func (*Cursor_nameContext) EnterRule

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

func (*Cursor_nameContext) ExitRule

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

func (*Cursor_nameContext) GetParser

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

func (*Cursor_nameContext) GetRuleContext

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

func (*Cursor_nameContext) Id

func (*Cursor_nameContext) IsCursor_nameContext

func (*Cursor_nameContext) IsCursor_nameContext()

func (*Cursor_nameContext) LOCAL_ID

func (s *Cursor_nameContext) LOCAL_ID() antlr.TerminalNode

func (*Cursor_nameContext) ToStringTree

func (s *Cursor_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Cursor_optionContext

type Cursor_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCursor_optionContext

func NewCursor_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_optionContext

func NewEmptyCursor_optionContext

func NewEmptyCursor_optionContext() *Cursor_optionContext

func (*Cursor_optionContext) CURSOR_CLOSE_ON_COMMIT

func (s *Cursor_optionContext) CURSOR_CLOSE_ON_COMMIT() antlr.TerminalNode

func (*Cursor_optionContext) CURSOR_DEFAULT

func (s *Cursor_optionContext) CURSOR_DEFAULT() antlr.TerminalNode

func (*Cursor_optionContext) EnterRule

func (s *Cursor_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Cursor_optionContext) ExitRule

func (s *Cursor_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Cursor_optionContext) GLOBAL

func (*Cursor_optionContext) GetParser

func (s *Cursor_optionContext) GetParser() antlr.Parser

func (*Cursor_optionContext) GetRuleContext

func (s *Cursor_optionContext) GetRuleContext() antlr.RuleContext

func (*Cursor_optionContext) IsCursor_optionContext

func (*Cursor_optionContext) IsCursor_optionContext()

func (*Cursor_optionContext) LOCAL

func (*Cursor_optionContext) On_off

func (*Cursor_optionContext) ToStringTree

func (s *Cursor_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Cursor_statementContext

type Cursor_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCursor_statementContext

func NewCursor_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_statementContext

func NewEmptyCursor_statementContext

func NewEmptyCursor_statementContext() *Cursor_statementContext

func (*Cursor_statementContext) CLOSE

func (*Cursor_statementContext) CURSOR

func (*Cursor_statementContext) Cursor_name

func (*Cursor_statementContext) DEALLOCATE

func (s *Cursor_statementContext) DEALLOCATE() antlr.TerminalNode

func (*Cursor_statementContext) Declare_cursor

func (s *Cursor_statementContext) Declare_cursor() IDeclare_cursorContext

func (*Cursor_statementContext) EnterRule

func (s *Cursor_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Cursor_statementContext) ExitRule

func (s *Cursor_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Cursor_statementContext) Fetch_cursor

func (*Cursor_statementContext) GLOBAL

func (*Cursor_statementContext) GetParser

func (s *Cursor_statementContext) GetParser() antlr.Parser

func (*Cursor_statementContext) GetRuleContext

func (s *Cursor_statementContext) GetRuleContext() antlr.RuleContext

func (*Cursor_statementContext) IsCursor_statementContext

func (*Cursor_statementContext) IsCursor_statementContext()

func (*Cursor_statementContext) OPEN

func (*Cursor_statementContext) SEMI

func (*Cursor_statementContext) ToStringTree

func (s *Cursor_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type DATEADDContext

type DATEADDContext struct {
	*Function_callContext
}

func NewDATEADDContext

func NewDATEADDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATEADDContext

func (*DATEADDContext) AllCOMMA

func (s *DATEADDContext) AllCOMMA() []antlr.TerminalNode

func (*DATEADDContext) AllExpression

func (s *DATEADDContext) AllExpression() []IExpressionContext

func (*DATEADDContext) COMMA

func (s *DATEADDContext) COMMA(i int) antlr.TerminalNode

func (*DATEADDContext) DATEADD

func (s *DATEADDContext) DATEADD() antlr.TerminalNode

func (*DATEADDContext) EnterRule

func (s *DATEADDContext) EnterRule(listener antlr.ParseTreeListener)

func (*DATEADDContext) ExitRule

func (s *DATEADDContext) ExitRule(listener antlr.ParseTreeListener)

func (*DATEADDContext) Expression

func (s *DATEADDContext) Expression(i int) IExpressionContext

func (*DATEADDContext) GetRuleContext

func (s *DATEADDContext) GetRuleContext() antlr.RuleContext

func (*DATEADDContext) ID

func (*DATEADDContext) LR_BRACKET

func (s *DATEADDContext) LR_BRACKET() antlr.TerminalNode

func (*DATEADDContext) RR_BRACKET

func (s *DATEADDContext) RR_BRACKET() antlr.TerminalNode

type DATEDIFFContext

type DATEDIFFContext struct {
	*Function_callContext
}

func NewDATEDIFFContext

func NewDATEDIFFContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATEDIFFContext

func (*DATEDIFFContext) AllCOMMA

func (s *DATEDIFFContext) AllCOMMA() []antlr.TerminalNode

func (*DATEDIFFContext) AllExpression

func (s *DATEDIFFContext) AllExpression() []IExpressionContext

func (*DATEDIFFContext) COMMA

func (s *DATEDIFFContext) COMMA(i int) antlr.TerminalNode

func (*DATEDIFFContext) DATEDIFF

func (s *DATEDIFFContext) DATEDIFF() antlr.TerminalNode

func (*DATEDIFFContext) EnterRule

func (s *DATEDIFFContext) EnterRule(listener antlr.ParseTreeListener)

func (*DATEDIFFContext) ExitRule

func (s *DATEDIFFContext) ExitRule(listener antlr.ParseTreeListener)

func (*DATEDIFFContext) Expression

func (s *DATEDIFFContext) Expression(i int) IExpressionContext

func (*DATEDIFFContext) GetRuleContext

func (s *DATEDIFFContext) GetRuleContext() antlr.RuleContext

func (*DATEDIFFContext) ID

func (*DATEDIFFContext) LR_BRACKET

func (s *DATEDIFFContext) LR_BRACKET() antlr.TerminalNode

func (*DATEDIFFContext) RR_BRACKET

func (s *DATEDIFFContext) RR_BRACKET() antlr.TerminalNode

type DATENAMEContext

type DATENAMEContext struct {
	*Function_callContext
}

func NewDATENAMEContext

func NewDATENAMEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATENAMEContext

func (*DATENAMEContext) COMMA

func (s *DATENAMEContext) COMMA() antlr.TerminalNode

func (*DATENAMEContext) DATENAME

func (s *DATENAMEContext) DATENAME() antlr.TerminalNode

func (*DATENAMEContext) EnterRule

func (s *DATENAMEContext) EnterRule(listener antlr.ParseTreeListener)

func (*DATENAMEContext) ExitRule

func (s *DATENAMEContext) ExitRule(listener antlr.ParseTreeListener)

func (*DATENAMEContext) Expression

func (s *DATENAMEContext) Expression() IExpressionContext

func (*DATENAMEContext) GetRuleContext

func (s *DATENAMEContext) GetRuleContext() antlr.RuleContext

func (*DATENAMEContext) ID

func (*DATENAMEContext) LR_BRACKET

func (s *DATENAMEContext) LR_BRACKET() antlr.TerminalNode

func (*DATENAMEContext) RR_BRACKET

func (s *DATENAMEContext) RR_BRACKET() antlr.TerminalNode

type DATEPARTContext

type DATEPARTContext struct {
	*Function_callContext
}

func NewDATEPARTContext

func NewDATEPARTContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *DATEPARTContext

func (*DATEPARTContext) COMMA

func (s *DATEPARTContext) COMMA() antlr.TerminalNode

func (*DATEPARTContext) DATEPART

func (s *DATEPARTContext) DATEPART() antlr.TerminalNode

func (*DATEPARTContext) EnterRule

func (s *DATEPARTContext) EnterRule(listener antlr.ParseTreeListener)

func (*DATEPARTContext) ExitRule

func (s *DATEPARTContext) ExitRule(listener antlr.ParseTreeListener)

func (*DATEPARTContext) Expression

func (s *DATEPARTContext) Expression() IExpressionContext

func (*DATEPARTContext) GetRuleContext

func (s *DATEPARTContext) GetRuleContext() antlr.RuleContext

func (*DATEPARTContext) ID

func (*DATEPARTContext) LR_BRACKET

func (s *DATEPARTContext) LR_BRACKET() antlr.TerminalNode

func (*DATEPARTContext) RR_BRACKET

func (s *DATEPARTContext) RR_BRACKET() antlr.TerminalNode

type Data_typeContext

type Data_typeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewData_typeContext

func NewData_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Data_typeContext

func NewEmptyData_typeContext

func NewEmptyData_typeContext() *Data_typeContext

func (*Data_typeContext) AllDECIMAL

func (s *Data_typeContext) AllDECIMAL() []antlr.TerminalNode

func (*Data_typeContext) BIGINT

func (s *Data_typeContext) BIGINT() antlr.TerminalNode

func (*Data_typeContext) COMMA

func (s *Data_typeContext) COMMA() antlr.TerminalNode

func (*Data_typeContext) DECIMAL

func (s *Data_typeContext) DECIMAL(i int) antlr.TerminalNode

func (*Data_typeContext) DOUBLE

func (s *Data_typeContext) DOUBLE() antlr.TerminalNode

func (*Data_typeContext) EnterRule

func (s *Data_typeContext) EnterRule(listener antlr.ParseTreeListener)

func (*Data_typeContext) ExitRule

func (s *Data_typeContext) ExitRule(listener antlr.ParseTreeListener)

func (*Data_typeContext) GetParser

func (s *Data_typeContext) GetParser() antlr.Parser

func (*Data_typeContext) GetRuleContext

func (s *Data_typeContext) GetRuleContext() antlr.RuleContext

func (*Data_typeContext) IDENTITY

func (s *Data_typeContext) IDENTITY() antlr.TerminalNode

func (*Data_typeContext) INT

func (*Data_typeContext) Id

func (s *Data_typeContext) Id() IIdContext

func (*Data_typeContext) IsData_typeContext

func (*Data_typeContext) IsData_typeContext()

func (*Data_typeContext) LR_BRACKET

func (s *Data_typeContext) LR_BRACKET() antlr.TerminalNode

func (*Data_typeContext) MAX

func (*Data_typeContext) PRECISION

func (s *Data_typeContext) PRECISION() antlr.TerminalNode

func (*Data_typeContext) RR_BRACKET

func (s *Data_typeContext) RR_BRACKET() antlr.TerminalNode

func (*Data_typeContext) SMALLINT

func (s *Data_typeContext) SMALLINT() antlr.TerminalNode

func (*Data_typeContext) TINYINT

func (s *Data_typeContext) TINYINT() antlr.TerminalNode

func (*Data_typeContext) ToStringTree

func (s *Data_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Database_file_specContext

type Database_file_specContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDatabase_file_specContext

func NewDatabase_file_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_file_specContext

func NewEmptyDatabase_file_specContext

func NewEmptyDatabase_file_specContext() *Database_file_specContext

func (*Database_file_specContext) EnterRule

func (s *Database_file_specContext) EnterRule(listener antlr.ParseTreeListener)

func (*Database_file_specContext) ExitRule

func (s *Database_file_specContext) ExitRule(listener antlr.ParseTreeListener)

func (*Database_file_specContext) File_group

func (*Database_file_specContext) File_spec

func (*Database_file_specContext) GetParser

func (s *Database_file_specContext) GetParser() antlr.Parser

func (*Database_file_specContext) GetRuleContext

func (s *Database_file_specContext) GetRuleContext() antlr.RuleContext

func (*Database_file_specContext) IsDatabase_file_specContext

func (*Database_file_specContext) IsDatabase_file_specContext()

func (*Database_file_specContext) ToStringTree

func (s *Database_file_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Database_filestream_optionContext

type Database_filestream_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDatabase_filestream_optionContext

func NewDatabase_filestream_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_filestream_optionContext

func NewEmptyDatabase_filestream_optionContext

func NewEmptyDatabase_filestream_optionContext() *Database_filestream_optionContext

func (*Database_filestream_optionContext) DIRECTORY_NAME

func (*Database_filestream_optionContext) EQUAL

func (*Database_filestream_optionContext) EnterRule

func (*Database_filestream_optionContext) ExitRule

func (*Database_filestream_optionContext) FULL

func (*Database_filestream_optionContext) GetParser

func (*Database_filestream_optionContext) GetRuleContext

func (*Database_filestream_optionContext) IsDatabase_filestream_optionContext

func (*Database_filestream_optionContext) IsDatabase_filestream_optionContext()

func (*Database_filestream_optionContext) LR_BRACKET

func (*Database_filestream_optionContext) NON_TRANSACTED_ACCESS

func (s *Database_filestream_optionContext) NON_TRANSACTED_ACCESS() antlr.TerminalNode

func (*Database_filestream_optionContext) OFF

func (*Database_filestream_optionContext) READ_ONLY

func (*Database_filestream_optionContext) RR_BRACKET

func (*Database_filestream_optionContext) STRING

func (*Database_filestream_optionContext) ToStringTree

func (s *Database_filestream_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Database_mirroring_optionContext

type Database_mirroring_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDatabase_mirroring_optionContext

func NewDatabase_mirroring_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_mirroring_optionContext

func NewEmptyDatabase_mirroring_optionContext

func NewEmptyDatabase_mirroring_optionContext() *Database_mirroring_optionContext

func (*Database_mirroring_optionContext) EnterRule

func (*Database_mirroring_optionContext) ExitRule

func (*Database_mirroring_optionContext) GetParser

func (*Database_mirroring_optionContext) GetRuleContext

func (*Database_mirroring_optionContext) IsDatabase_mirroring_optionContext

func (*Database_mirroring_optionContext) IsDatabase_mirroring_optionContext()

func (*Database_mirroring_optionContext) Mirroring_set_option

func (*Database_mirroring_optionContext) ToStringTree

func (s *Database_mirroring_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Database_optionspecContext

type Database_optionspecContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDatabase_optionspecContext

func NewDatabase_optionspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_optionspecContext

func NewEmptyDatabase_optionspecContext

func NewEmptyDatabase_optionspecContext() *Database_optionspecContext

func (*Database_optionspecContext) Auto_option

func (*Database_optionspecContext) Change_tracking_option

func (s *Database_optionspecContext) Change_tracking_option() IChange_tracking_optionContext

func (*Database_optionspecContext) Containment_option

func (*Database_optionspecContext) Cursor_option

func (*Database_optionspecContext) Database_filestream_option

func (s *Database_optionspecContext) Database_filestream_option() IDatabase_filestream_optionContext

func (*Database_optionspecContext) Database_mirroring_option

func (s *Database_optionspecContext) Database_mirroring_option() IDatabase_mirroring_optionContext

func (*Database_optionspecContext) Date_correlation_optimization_option

func (s *Database_optionspecContext) Date_correlation_optimization_option() IDate_correlation_optimization_optionContext

func (*Database_optionspecContext) Db_encryption_option

func (s *Database_optionspecContext) Db_encryption_option() IDb_encryption_optionContext

func (*Database_optionspecContext) Db_state_option

func (*Database_optionspecContext) Db_update_option

func (*Database_optionspecContext) Db_user_access_option

func (s *Database_optionspecContext) Db_user_access_option() IDb_user_access_optionContext

func (*Database_optionspecContext) Delayed_durability_option

func (s *Database_optionspecContext) Delayed_durability_option() IDelayed_durability_optionContext

func (*Database_optionspecContext) EnterRule

func (s *Database_optionspecContext) EnterRule(listener antlr.ParseTreeListener)

func (*Database_optionspecContext) ExitRule

func (s *Database_optionspecContext) ExitRule(listener antlr.ParseTreeListener)

func (*Database_optionspecContext) External_access_option

func (s *Database_optionspecContext) External_access_option() IExternal_access_optionContext

func (*Database_optionspecContext) FILESTREAM

func (*Database_optionspecContext) GetParser

func (s *Database_optionspecContext) GetParser() antlr.Parser

func (*Database_optionspecContext) GetRuleContext

func (s *Database_optionspecContext) GetRuleContext() antlr.RuleContext

func (*Database_optionspecContext) Hadr_options

func (*Database_optionspecContext) IsDatabase_optionspecContext

func (*Database_optionspecContext) IsDatabase_optionspecContext()

func (*Database_optionspecContext) Mixed_page_allocation_option

func (s *Database_optionspecContext) Mixed_page_allocation_option() IMixed_page_allocation_optionContext

func (*Database_optionspecContext) Parameterization_option

func (s *Database_optionspecContext) Parameterization_option() IParameterization_optionContext

func (*Database_optionspecContext) Recovery_option

func (*Database_optionspecContext) Service_broker_option

func (s *Database_optionspecContext) Service_broker_option() IService_broker_optionContext

func (*Database_optionspecContext) Snapshot_option

func (*Database_optionspecContext) Sql_option

func (*Database_optionspecContext) Target_recovery_time_option

func (s *Database_optionspecContext) Target_recovery_time_option() ITarget_recovery_time_optionContext

func (*Database_optionspecContext) Termination

func (*Database_optionspecContext) ToStringTree

func (s *Database_optionspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Date_correlation_optimization_optionContext

type Date_correlation_optimization_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDate_correlation_optimization_optionContext

func NewDate_correlation_optimization_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Date_correlation_optimization_optionContext

func NewEmptyDate_correlation_optimization_optionContext

func NewEmptyDate_correlation_optimization_optionContext() *Date_correlation_optimization_optionContext

func (*Date_correlation_optimization_optionContext) DATE_CORRELATION_OPTIMIZATION

func (s *Date_correlation_optimization_optionContext) DATE_CORRELATION_OPTIMIZATION() antlr.TerminalNode

func (*Date_correlation_optimization_optionContext) EnterRule

func (*Date_correlation_optimization_optionContext) ExitRule

func (*Date_correlation_optimization_optionContext) GetParser

func (*Date_correlation_optimization_optionContext) GetRuleContext

func (*Date_correlation_optimization_optionContext) IsDate_correlation_optimization_optionContext

func (*Date_correlation_optimization_optionContext) IsDate_correlation_optimization_optionContext()

func (*Date_correlation_optimization_optionContext) On_off

func (*Date_correlation_optimization_optionContext) ToStringTree

func (s *Date_correlation_optimization_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Date_optionsContext

type Date_optionsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDate_optionsContext

func NewDate_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Date_optionsContext

func NewEmptyDate_optionsContext

func NewEmptyDate_optionsContext() *Date_optionsContext

func (*Date_optionsContext) EQUAL

func (*Date_optionsContext) EXPIRY_DATE

func (s *Date_optionsContext) EXPIRY_DATE() antlr.TerminalNode

func (*Date_optionsContext) EnterRule

func (s *Date_optionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Date_optionsContext) ExitRule

func (s *Date_optionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Date_optionsContext) GetParser

func (s *Date_optionsContext) GetParser() antlr.Parser

func (*Date_optionsContext) GetRuleContext

func (s *Date_optionsContext) GetRuleContext() antlr.RuleContext

func (*Date_optionsContext) IsDate_optionsContext

func (*Date_optionsContext) IsDate_optionsContext()

func (*Date_optionsContext) START_DATE

func (s *Date_optionsContext) START_DATE() antlr.TerminalNode

func (*Date_optionsContext) STRING

func (*Date_optionsContext) ToStringTree

func (s *Date_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Db_encryption_optionContext

type Db_encryption_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDb_encryption_optionContext

func NewDb_encryption_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_encryption_optionContext

func NewEmptyDb_encryption_optionContext

func NewEmptyDb_encryption_optionContext() *Db_encryption_optionContext

func (*Db_encryption_optionContext) ENCRYPTION

func (*Db_encryption_optionContext) EnterRule

func (s *Db_encryption_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Db_encryption_optionContext) ExitRule

func (s *Db_encryption_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Db_encryption_optionContext) GetParser

func (s *Db_encryption_optionContext) GetParser() antlr.Parser

func (*Db_encryption_optionContext) GetRuleContext

func (s *Db_encryption_optionContext) GetRuleContext() antlr.RuleContext

func (*Db_encryption_optionContext) IsDb_encryption_optionContext

func (*Db_encryption_optionContext) IsDb_encryption_optionContext()

func (*Db_encryption_optionContext) On_off

func (*Db_encryption_optionContext) ToStringTree

func (s *Db_encryption_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Db_state_optionContext

type Db_state_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDb_state_optionContext

func NewDb_state_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_state_optionContext

func NewEmptyDb_state_optionContext

func NewEmptyDb_state_optionContext() *Db_state_optionContext

func (*Db_state_optionContext) EMERGENCY

func (s *Db_state_optionContext) EMERGENCY() antlr.TerminalNode

func (*Db_state_optionContext) EnterRule

func (s *Db_state_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Db_state_optionContext) ExitRule

func (s *Db_state_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Db_state_optionContext) GetParser

func (s *Db_state_optionContext) GetParser() antlr.Parser

func (*Db_state_optionContext) GetRuleContext

func (s *Db_state_optionContext) GetRuleContext() antlr.RuleContext

func (*Db_state_optionContext) IsDb_state_optionContext

func (*Db_state_optionContext) IsDb_state_optionContext()

func (*Db_state_optionContext) OFFLINE

func (*Db_state_optionContext) ONLINE

func (*Db_state_optionContext) ToStringTree

func (s *Db_state_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Db_update_optionContext

type Db_update_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDb_update_optionContext

func NewDb_update_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_update_optionContext

func NewEmptyDb_update_optionContext

func NewEmptyDb_update_optionContext() *Db_update_optionContext

func (*Db_update_optionContext) EnterRule

func (s *Db_update_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Db_update_optionContext) ExitRule

func (s *Db_update_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Db_update_optionContext) GetParser

func (s *Db_update_optionContext) GetParser() antlr.Parser

func (*Db_update_optionContext) GetRuleContext

func (s *Db_update_optionContext) GetRuleContext() antlr.RuleContext

func (*Db_update_optionContext) IsDb_update_optionContext

func (*Db_update_optionContext) IsDb_update_optionContext()

func (*Db_update_optionContext) READ_ONLY

func (*Db_update_optionContext) READ_WRITE

func (s *Db_update_optionContext) READ_WRITE() antlr.TerminalNode

func (*Db_update_optionContext) ToStringTree

func (s *Db_update_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Db_user_access_optionContext

type Db_user_access_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDb_user_access_optionContext

func NewDb_user_access_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_user_access_optionContext

func NewEmptyDb_user_access_optionContext

func NewEmptyDb_user_access_optionContext() *Db_user_access_optionContext

func (*Db_user_access_optionContext) EnterRule

func (s *Db_user_access_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Db_user_access_optionContext) ExitRule

func (*Db_user_access_optionContext) GetParser

func (s *Db_user_access_optionContext) GetParser() antlr.Parser

func (*Db_user_access_optionContext) GetRuleContext

func (s *Db_user_access_optionContext) GetRuleContext() antlr.RuleContext

func (*Db_user_access_optionContext) IsDb_user_access_optionContext

func (*Db_user_access_optionContext) IsDb_user_access_optionContext()

func (*Db_user_access_optionContext) MULTI_USER

func (*Db_user_access_optionContext) RESTRICTED_USER

func (s *Db_user_access_optionContext) RESTRICTED_USER() antlr.TerminalNode

func (*Db_user_access_optionContext) SINGLE_USER

func (*Db_user_access_optionContext) ToStringTree

func (s *Db_user_access_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Dbcc_clauseContext

type Dbcc_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDbcc_clauseContext

func NewDbcc_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_clauseContext

func NewEmptyDbcc_clauseContext

func NewEmptyDbcc_clauseContext() *Dbcc_clauseContext

func (*Dbcc_clauseContext) DBCC

func (*Dbcc_clauseContext) Dbcc_options

func (s *Dbcc_clauseContext) Dbcc_options() IDbcc_optionsContext

func (*Dbcc_clauseContext) EnterRule

func (s *Dbcc_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Dbcc_clauseContext) ExitRule

func (s *Dbcc_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Dbcc_clauseContext) Expression_list

func (s *Dbcc_clauseContext) Expression_list() IExpression_listContext

func (*Dbcc_clauseContext) GetName

func (*Dbcc_clauseContext) GetParser

func (s *Dbcc_clauseContext) GetParser() antlr.Parser

func (*Dbcc_clauseContext) GetRuleContext

func (s *Dbcc_clauseContext) GetRuleContext() antlr.RuleContext

func (*Dbcc_clauseContext) IsDbcc_clauseContext

func (*Dbcc_clauseContext) IsDbcc_clauseContext()

func (*Dbcc_clauseContext) LR_BRACKET

func (s *Dbcc_clauseContext) LR_BRACKET() antlr.TerminalNode

func (*Dbcc_clauseContext) RR_BRACKET

func (s *Dbcc_clauseContext) RR_BRACKET() antlr.TerminalNode

func (*Dbcc_clauseContext) SEMI

func (*Dbcc_clauseContext) SetName

func (s *Dbcc_clauseContext) SetName(v ISimple_idContext)

func (*Dbcc_clauseContext) Simple_id

func (s *Dbcc_clauseContext) Simple_id() ISimple_idContext

func (*Dbcc_clauseContext) ToStringTree

func (s *Dbcc_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Dbcc_clauseContext) WITH

type Dbcc_optionsContext

type Dbcc_optionsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDbcc_optionsContext

func NewDbcc_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dbcc_optionsContext

func NewEmptyDbcc_optionsContext

func NewEmptyDbcc_optionsContext() *Dbcc_optionsContext

func (*Dbcc_optionsContext) AllSimple_id

func (s *Dbcc_optionsContext) AllSimple_id() []ISimple_idContext

func (*Dbcc_optionsContext) COMMA

func (*Dbcc_optionsContext) EnterRule

func (s *Dbcc_optionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Dbcc_optionsContext) ExitRule

func (s *Dbcc_optionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Dbcc_optionsContext) GetParser

func (s *Dbcc_optionsContext) GetParser() antlr.Parser

func (*Dbcc_optionsContext) GetRuleContext

func (s *Dbcc_optionsContext) GetRuleContext() antlr.RuleContext

func (*Dbcc_optionsContext) IsDbcc_optionsContext

func (*Dbcc_optionsContext) IsDbcc_optionsContext()

func (*Dbcc_optionsContext) Simple_id

func (s *Dbcc_optionsContext) Simple_id(i int) ISimple_idContext

func (*Dbcc_optionsContext) ToStringTree

func (s *Dbcc_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Ddl_clauseContext

type Ddl_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDdl_clauseContext

func NewDdl_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ddl_clauseContext

func NewEmptyDdl_clauseContext

func NewEmptyDdl_clauseContext() *Ddl_clauseContext

func (*Ddl_clauseContext) Alter_application_role

func (s *Ddl_clauseContext) Alter_application_role() IAlter_application_roleContext

func (*Ddl_clauseContext) Alter_assembly

func (s *Ddl_clauseContext) Alter_assembly() IAlter_assemblyContext

func (*Ddl_clauseContext) Alter_asymmetric_key

func (s *Ddl_clauseContext) Alter_asymmetric_key() IAlter_asymmetric_keyContext

func (*Ddl_clauseContext) Alter_authorization

func (s *Ddl_clauseContext) Alter_authorization() IAlter_authorizationContext

func (*Ddl_clauseContext) Alter_authorization_for_azure_dw

func (s *Ddl_clauseContext) Alter_authorization_for_azure_dw() IAlter_authorization_for_azure_dwContext

func (*Ddl_clauseContext) Alter_authorization_for_parallel_dw

func (s *Ddl_clauseContext) Alter_authorization_for_parallel_dw() IAlter_authorization_for_parallel_dwContext

func (*Ddl_clauseContext) Alter_authorization_for_sql_database

func (s *Ddl_clauseContext) Alter_authorization_for_sql_database() IAlter_authorization_for_sql_databaseContext

func (*Ddl_clauseContext) Alter_availability_group

func (s *Ddl_clauseContext) Alter_availability_group() IAlter_availability_groupContext

func (*Ddl_clauseContext) Alter_certificate

func (s *Ddl_clauseContext) Alter_certificate() IAlter_certificateContext

func (*Ddl_clauseContext) Alter_column_encryption_key

func (s *Ddl_clauseContext) Alter_column_encryption_key() IAlter_column_encryption_keyContext

func (*Ddl_clauseContext) Alter_credential

func (s *Ddl_clauseContext) Alter_credential() IAlter_credentialContext

func (*Ddl_clauseContext) Alter_cryptographic_provider

func (s *Ddl_clauseContext) Alter_cryptographic_provider() IAlter_cryptographic_providerContext

func (*Ddl_clauseContext) Alter_database

func (s *Ddl_clauseContext) Alter_database() IAlter_databaseContext

func (*Ddl_clauseContext) Alter_db_role

func (s *Ddl_clauseContext) Alter_db_role() IAlter_db_roleContext

func (*Ddl_clauseContext) Alter_endpoint

func (s *Ddl_clauseContext) Alter_endpoint() IAlter_endpointContext

func (*Ddl_clauseContext) Alter_external_data_source

func (s *Ddl_clauseContext) Alter_external_data_source() IAlter_external_data_sourceContext

func (*Ddl_clauseContext) Alter_external_library

func (s *Ddl_clauseContext) Alter_external_library() IAlter_external_libraryContext

func (*Ddl_clauseContext) Alter_external_resource_pool

func (s *Ddl_clauseContext) Alter_external_resource_pool() IAlter_external_resource_poolContext

func (*Ddl_clauseContext) Alter_fulltext_catalog

func (s *Ddl_clauseContext) Alter_fulltext_catalog() IAlter_fulltext_catalogContext

func (*Ddl_clauseContext) Alter_fulltext_stoplist

func (s *Ddl_clauseContext) Alter_fulltext_stoplist() IAlter_fulltext_stoplistContext

func (*Ddl_clauseContext) Alter_login_azure_sql

func (s *Ddl_clauseContext) Alter_login_azure_sql() IAlter_login_azure_sqlContext

func (*Ddl_clauseContext) Alter_login_azure_sql_dw_and_pdw

func (s *Ddl_clauseContext) Alter_login_azure_sql_dw_and_pdw() IAlter_login_azure_sql_dw_and_pdwContext

func (*Ddl_clauseContext) Alter_login_sql_server

func (s *Ddl_clauseContext) Alter_login_sql_server() IAlter_login_sql_serverContext

func (*Ddl_clauseContext) Alter_master_key_azure_sql

func (s *Ddl_clauseContext) Alter_master_key_azure_sql() IAlter_master_key_azure_sqlContext

func (*Ddl_clauseContext) Alter_master_key_sql_server

func (s *Ddl_clauseContext) Alter_master_key_sql_server() IAlter_master_key_sql_serverContext

func (*Ddl_clauseContext) Alter_message_type

func (s *Ddl_clauseContext) Alter_message_type() IAlter_message_typeContext

func (*Ddl_clauseContext) Alter_partition_function

func (s *Ddl_clauseContext) Alter_partition_function() IAlter_partition_functionContext

func (*Ddl_clauseContext) Alter_partition_scheme

func (s *Ddl_clauseContext) Alter_partition_scheme() IAlter_partition_schemeContext

func (*Ddl_clauseContext) Alter_remote_service_binding

func (s *Ddl_clauseContext) Alter_remote_service_binding() IAlter_remote_service_bindingContext

func (*Ddl_clauseContext) Alter_resource_governor

func (s *Ddl_clauseContext) Alter_resource_governor() IAlter_resource_governorContext

func (*Ddl_clauseContext) Alter_schema_azure_sql_dw_and_pdw

func (s *Ddl_clauseContext) Alter_schema_azure_sql_dw_and_pdw() IAlter_schema_azure_sql_dw_and_pdwContext

func (*Ddl_clauseContext) Alter_schema_sql

func (s *Ddl_clauseContext) Alter_schema_sql() IAlter_schema_sqlContext

func (*Ddl_clauseContext) Alter_sequence

func (s *Ddl_clauseContext) Alter_sequence() IAlter_sequenceContext

func (*Ddl_clauseContext) Alter_server_audit

func (s *Ddl_clauseContext) Alter_server_audit() IAlter_server_auditContext

func (*Ddl_clauseContext) Alter_server_audit_specification

func (s *Ddl_clauseContext) Alter_server_audit_specification() IAlter_server_audit_specificationContext

func (*Ddl_clauseContext) Alter_server_configuration

func (s *Ddl_clauseContext) Alter_server_configuration() IAlter_server_configurationContext

func (*Ddl_clauseContext) Alter_server_role

func (s *Ddl_clauseContext) Alter_server_role() IAlter_server_roleContext

func (*Ddl_clauseContext) Alter_server_role_pdw

func (s *Ddl_clauseContext) Alter_server_role_pdw() IAlter_server_role_pdwContext

func (*Ddl_clauseContext) Alter_service

func (s *Ddl_clauseContext) Alter_service() IAlter_serviceContext

func (*Ddl_clauseContext) Alter_service_master_key

func (s *Ddl_clauseContext) Alter_service_master_key() IAlter_service_master_keyContext

func (*Ddl_clauseContext) Alter_symmetric_key

func (s *Ddl_clauseContext) Alter_symmetric_key() IAlter_symmetric_keyContext

func (*Ddl_clauseContext) Alter_table

func (s *Ddl_clauseContext) Alter_table() IAlter_tableContext

func (*Ddl_clauseContext) Alter_user

func (s *Ddl_clauseContext) Alter_user() IAlter_userContext

func (*Ddl_clauseContext) Alter_user_azure_sql

func (s *Ddl_clauseContext) Alter_user_azure_sql() IAlter_user_azure_sqlContext

func (*Ddl_clauseContext) Alter_workload_group

func (s *Ddl_clauseContext) Alter_workload_group() IAlter_workload_groupContext

func (*Ddl_clauseContext) Create_application_role

func (s *Ddl_clauseContext) Create_application_role() ICreate_application_roleContext

func (*Ddl_clauseContext) Create_assembly

func (s *Ddl_clauseContext) Create_assembly() ICreate_assemblyContext

func (*Ddl_clauseContext) Create_asymmetric_key

func (s *Ddl_clauseContext) Create_asymmetric_key() ICreate_asymmetric_keyContext

func (*Ddl_clauseContext) Create_column_encryption_key

func (s *Ddl_clauseContext) Create_column_encryption_key() ICreate_column_encryption_keyContext

func (*Ddl_clauseContext) Create_column_master_key

func (s *Ddl_clauseContext) Create_column_master_key() ICreate_column_master_keyContext

func (*Ddl_clauseContext) Create_credential

func (s *Ddl_clauseContext) Create_credential() ICreate_credentialContext

func (*Ddl_clauseContext) Create_cryptographic_provider

func (s *Ddl_clauseContext) Create_cryptographic_provider() ICreate_cryptographic_providerContext

func (*Ddl_clauseContext) Create_database

func (s *Ddl_clauseContext) Create_database() ICreate_databaseContext

func (*Ddl_clauseContext) Create_db_role

func (s *Ddl_clauseContext) Create_db_role() ICreate_db_roleContext

func (*Ddl_clauseContext) Create_event_notification

func (s *Ddl_clauseContext) Create_event_notification() ICreate_event_notificationContext

func (*Ddl_clauseContext) Create_external_library

func (s *Ddl_clauseContext) Create_external_library() ICreate_external_libraryContext

func (*Ddl_clauseContext) Create_external_resource_pool

func (s *Ddl_clauseContext) Create_external_resource_pool() ICreate_external_resource_poolContext

func (*Ddl_clauseContext) Create_fulltext_catalog

func (s *Ddl_clauseContext) Create_fulltext_catalog() ICreate_fulltext_catalogContext

func (*Ddl_clauseContext) Create_fulltext_stoplist

func (s *Ddl_clauseContext) Create_fulltext_stoplist() ICreate_fulltext_stoplistContext

func (*Ddl_clauseContext) Create_index

func (s *Ddl_clauseContext) Create_index() ICreate_indexContext

func (*Ddl_clauseContext) Create_login_azure_sql

func (s *Ddl_clauseContext) Create_login_azure_sql() ICreate_login_azure_sqlContext

func (*Ddl_clauseContext) Create_login_pdw

func (s *Ddl_clauseContext) Create_login_pdw() ICreate_login_pdwContext

func (*Ddl_clauseContext) Create_login_sql_server

func (s *Ddl_clauseContext) Create_login_sql_server() ICreate_login_sql_serverContext

func (*Ddl_clauseContext) Create_master_key_azure_sql

func (s *Ddl_clauseContext) Create_master_key_azure_sql() ICreate_master_key_azure_sqlContext

func (*Ddl_clauseContext) Create_master_key_sql_server

func (s *Ddl_clauseContext) Create_master_key_sql_server() ICreate_master_key_sql_serverContext

func (*Ddl_clauseContext) Create_or_alter_broker_priority

func (s *Ddl_clauseContext) Create_or_alter_broker_priority() ICreate_or_alter_broker_priorityContext

func (*Ddl_clauseContext) Create_or_alter_event_session

func (s *Ddl_clauseContext) Create_or_alter_event_session() ICreate_or_alter_event_sessionContext

func (*Ddl_clauseContext) Create_or_alter_function

func (s *Ddl_clauseContext) Create_or_alter_function() ICreate_or_alter_functionContext

func (*Ddl_clauseContext) Create_or_alter_procedure

func (s *Ddl_clauseContext) Create_or_alter_procedure() ICreate_or_alter_procedureContext

func (*Ddl_clauseContext) Create_or_alter_trigger

func (s *Ddl_clauseContext) Create_or_alter_trigger() ICreate_or_alter_triggerContext

func (*Ddl_clauseContext) Create_remote_service_binding

func (s *Ddl_clauseContext) Create_remote_service_binding() ICreate_remote_service_bindingContext

func (*Ddl_clauseContext) Create_resource_pool

func (s *Ddl_clauseContext) Create_resource_pool() ICreate_resource_poolContext

func (*Ddl_clauseContext) Create_route

func (s *Ddl_clauseContext) Create_route() ICreate_routeContext

func (*Ddl_clauseContext) Create_rule

func (s *Ddl_clauseContext) Create_rule() ICreate_ruleContext

func (*Ddl_clauseContext) Create_schema

func (s *Ddl_clauseContext) Create_schema() ICreate_schemaContext

func (*Ddl_clauseContext) Create_schema_azure_sql_dw_and_pdw

func (s *Ddl_clauseContext) Create_schema_azure_sql_dw_and_pdw() ICreate_schema_azure_sql_dw_and_pdwContext

func (*Ddl_clauseContext) Create_search_property_list

func (s *Ddl_clauseContext) Create_search_property_list() ICreate_search_property_listContext

func (*Ddl_clauseContext) Create_security_policy

func (s *Ddl_clauseContext) Create_security_policy() ICreate_security_policyContext

func (*Ddl_clauseContext) Create_sequence

func (s *Ddl_clauseContext) Create_sequence() ICreate_sequenceContext

func (*Ddl_clauseContext) Create_server_audit

func (s *Ddl_clauseContext) Create_server_audit() ICreate_server_auditContext

func (*Ddl_clauseContext) Create_server_audit_specification

func (s *Ddl_clauseContext) Create_server_audit_specification() ICreate_server_audit_specificationContext

func (*Ddl_clauseContext) Create_server_role

func (s *Ddl_clauseContext) Create_server_role() ICreate_server_roleContext

func (*Ddl_clauseContext) Create_service

func (s *Ddl_clauseContext) Create_service() ICreate_serviceContext

func (*Ddl_clauseContext) Create_statistics

func (s *Ddl_clauseContext) Create_statistics() ICreate_statisticsContext

func (*Ddl_clauseContext) Create_symmetric_key

func (s *Ddl_clauseContext) Create_symmetric_key() ICreate_symmetric_keyContext

func (*Ddl_clauseContext) Create_synonym

func (s *Ddl_clauseContext) Create_synonym() ICreate_synonymContext

func (*Ddl_clauseContext) Create_table

func (s *Ddl_clauseContext) Create_table() ICreate_tableContext

func (*Ddl_clauseContext) Create_type

func (s *Ddl_clauseContext) Create_type() ICreate_typeContext

func (*Ddl_clauseContext) Create_user

func (s *Ddl_clauseContext) Create_user() ICreate_userContext

func (*Ddl_clauseContext) Create_user_azure_sql_dw

func (s *Ddl_clauseContext) Create_user_azure_sql_dw() ICreate_user_azure_sql_dwContext

func (*Ddl_clauseContext) Create_view

func (s *Ddl_clauseContext) Create_view() ICreate_viewContext

func (*Ddl_clauseContext) Create_workload_group

func (s *Ddl_clauseContext) Create_workload_group() ICreate_workload_groupContext

func (*Ddl_clauseContext) Create_xml_schema_collection

func (s *Ddl_clauseContext) Create_xml_schema_collection() ICreate_xml_schema_collectionContext

func (*Ddl_clauseContext) Disable_trigger

func (s *Ddl_clauseContext) Disable_trigger() IDisable_triggerContext

func (*Ddl_clauseContext) Drop_aggregate

func (s *Ddl_clauseContext) Drop_aggregate() IDrop_aggregateContext

func (*Ddl_clauseContext) Drop_application_role

func (s *Ddl_clauseContext) Drop_application_role() IDrop_application_roleContext

func (*Ddl_clauseContext) Drop_assembly

func (s *Ddl_clauseContext) Drop_assembly() IDrop_assemblyContext

func (*Ddl_clauseContext) Drop_asymmetric_key

func (s *Ddl_clauseContext) Drop_asymmetric_key() IDrop_asymmetric_keyContext

func (*Ddl_clauseContext) Drop_availability_group

func (s *Ddl_clauseContext) Drop_availability_group() IDrop_availability_groupContext

func (*Ddl_clauseContext) Drop_broker_priority

func (s *Ddl_clauseContext) Drop_broker_priority() IDrop_broker_priorityContext

func (*Ddl_clauseContext) Drop_certificate

func (s *Ddl_clauseContext) Drop_certificate() IDrop_certificateContext

func (*Ddl_clauseContext) Drop_column_encryption_key

func (s *Ddl_clauseContext) Drop_column_encryption_key() IDrop_column_encryption_keyContext

func (*Ddl_clauseContext) Drop_column_master_key

func (s *Ddl_clauseContext) Drop_column_master_key() IDrop_column_master_keyContext

func (*Ddl_clauseContext) Drop_contract

func (s *Ddl_clauseContext) Drop_contract() IDrop_contractContext

func (*Ddl_clauseContext) Drop_credential

func (s *Ddl_clauseContext) Drop_credential() IDrop_credentialContext

func (*Ddl_clauseContext) Drop_cryptograhic_provider

func (s *Ddl_clauseContext) Drop_cryptograhic_provider() IDrop_cryptograhic_providerContext

func (*Ddl_clauseContext) Drop_database

func (s *Ddl_clauseContext) Drop_database() IDrop_databaseContext

func (*Ddl_clauseContext) Drop_database_audit_specification

func (s *Ddl_clauseContext) Drop_database_audit_specification() IDrop_database_audit_specificationContext

func (*Ddl_clauseContext) Drop_database_scoped_credential

func (s *Ddl_clauseContext) Drop_database_scoped_credential() IDrop_database_scoped_credentialContext

func (*Ddl_clauseContext) Drop_db_role

func (s *Ddl_clauseContext) Drop_db_role() IDrop_db_roleContext

func (*Ddl_clauseContext) Drop_default

func (s *Ddl_clauseContext) Drop_default() IDrop_defaultContext

func (*Ddl_clauseContext) Drop_endpoint

func (s *Ddl_clauseContext) Drop_endpoint() IDrop_endpointContext

func (*Ddl_clauseContext) Drop_event_notifications

func (s *Ddl_clauseContext) Drop_event_notifications() IDrop_event_notificationsContext

func (*Ddl_clauseContext) Drop_event_session

func (s *Ddl_clauseContext) Drop_event_session() IDrop_event_sessionContext

func (*Ddl_clauseContext) Drop_external_data_source

func (s *Ddl_clauseContext) Drop_external_data_source() IDrop_external_data_sourceContext

func (*Ddl_clauseContext) Drop_external_file_format

func (s *Ddl_clauseContext) Drop_external_file_format() IDrop_external_file_formatContext

func (*Ddl_clauseContext) Drop_external_library

func (s *Ddl_clauseContext) Drop_external_library() IDrop_external_libraryContext

func (*Ddl_clauseContext) Drop_external_resource_pool

func (s *Ddl_clauseContext) Drop_external_resource_pool() IDrop_external_resource_poolContext

func (*Ddl_clauseContext) Drop_external_table

func (s *Ddl_clauseContext) Drop_external_table() IDrop_external_tableContext

func (*Ddl_clauseContext) Drop_fulltext_catalog

func (s *Ddl_clauseContext) Drop_fulltext_catalog() IDrop_fulltext_catalogContext

func (*Ddl_clauseContext) Drop_fulltext_index

func (s *Ddl_clauseContext) Drop_fulltext_index() IDrop_fulltext_indexContext

func (*Ddl_clauseContext) Drop_fulltext_stoplist

func (s *Ddl_clauseContext) Drop_fulltext_stoplist() IDrop_fulltext_stoplistContext

func (*Ddl_clauseContext) Drop_function

func (s *Ddl_clauseContext) Drop_function() IDrop_functionContext

func (*Ddl_clauseContext) Drop_index

func (s *Ddl_clauseContext) Drop_index() IDrop_indexContext

func (*Ddl_clauseContext) Drop_login

func (s *Ddl_clauseContext) Drop_login() IDrop_loginContext

func (*Ddl_clauseContext) Drop_master_key

func (s *Ddl_clauseContext) Drop_master_key() IDrop_master_keyContext

func (*Ddl_clauseContext) Drop_message_type

func (s *Ddl_clauseContext) Drop_message_type() IDrop_message_typeContext

func (*Ddl_clauseContext) Drop_partition_function

func (s *Ddl_clauseContext) Drop_partition_function() IDrop_partition_functionContext

func (*Ddl_clauseContext) Drop_partition_scheme

func (s *Ddl_clauseContext) Drop_partition_scheme() IDrop_partition_schemeContext

func (*Ddl_clauseContext) Drop_procedure

func (s *Ddl_clauseContext) Drop_procedure() IDrop_procedureContext

func (*Ddl_clauseContext) Drop_queue

func (s *Ddl_clauseContext) Drop_queue() IDrop_queueContext

func (*Ddl_clauseContext) Drop_remote_service_binding

func (s *Ddl_clauseContext) Drop_remote_service_binding() IDrop_remote_service_bindingContext

func (*Ddl_clauseContext) Drop_resource_pool

func (s *Ddl_clauseContext) Drop_resource_pool() IDrop_resource_poolContext

func (*Ddl_clauseContext) Drop_route

func (s *Ddl_clauseContext) Drop_route() IDrop_routeContext

func (*Ddl_clauseContext) Drop_rule

func (s *Ddl_clauseContext) Drop_rule() IDrop_ruleContext

func (*Ddl_clauseContext) Drop_schema

func (s *Ddl_clauseContext) Drop_schema() IDrop_schemaContext

func (*Ddl_clauseContext) Drop_search_property_list

func (s *Ddl_clauseContext) Drop_search_property_list() IDrop_search_property_listContext

func (*Ddl_clauseContext) Drop_security_policy

func (s *Ddl_clauseContext) Drop_security_policy() IDrop_security_policyContext

func (*Ddl_clauseContext) Drop_sequence

func (s *Ddl_clauseContext) Drop_sequence() IDrop_sequenceContext

func (*Ddl_clauseContext) Drop_server_audit

func (s *Ddl_clauseContext) Drop_server_audit() IDrop_server_auditContext

func (*Ddl_clauseContext) Drop_server_audit_specification

func (s *Ddl_clauseContext) Drop_server_audit_specification() IDrop_server_audit_specificationContext

func (*Ddl_clauseContext) Drop_server_role

func (s *Ddl_clauseContext) Drop_server_role() IDrop_server_roleContext

func (*Ddl_clauseContext) Drop_service

func (s *Ddl_clauseContext) Drop_service() IDrop_serviceContext

func (*Ddl_clauseContext) Drop_signature

func (s *Ddl_clauseContext) Drop_signature() IDrop_signatureContext

func (*Ddl_clauseContext) Drop_statistics

func (s *Ddl_clauseContext) Drop_statistics() IDrop_statisticsContext

func (*Ddl_clauseContext) Drop_statistics_name_azure_dw_and_pdw

func (s *Ddl_clauseContext) Drop_statistics_name_azure_dw_and_pdw() IDrop_statistics_name_azure_dw_and_pdwContext

func (*Ddl_clauseContext) Drop_symmetric_key

func (s *Ddl_clauseContext) Drop_symmetric_key() IDrop_symmetric_keyContext

func (*Ddl_clauseContext) Drop_synonym

func (s *Ddl_clauseContext) Drop_synonym() IDrop_synonymContext

func (*Ddl_clauseContext) Drop_table

func (s *Ddl_clauseContext) Drop_table() IDrop_tableContext

func (*Ddl_clauseContext) Drop_trigger

func (s *Ddl_clauseContext) Drop_trigger() IDrop_triggerContext

func (*Ddl_clauseContext) Drop_type

func (s *Ddl_clauseContext) Drop_type() IDrop_typeContext

func (*Ddl_clauseContext) Drop_user

func (s *Ddl_clauseContext) Drop_user() IDrop_userContext

func (*Ddl_clauseContext) Drop_view

func (s *Ddl_clauseContext) Drop_view() IDrop_viewContext

func (*Ddl_clauseContext) Drop_workload_group

func (s *Ddl_clauseContext) Drop_workload_group() IDrop_workload_groupContext

func (*Ddl_clauseContext) Drop_xml_schema_collection

func (s *Ddl_clauseContext) Drop_xml_schema_collection() IDrop_xml_schema_collectionContext

func (*Ddl_clauseContext) Enable_trigger

func (s *Ddl_clauseContext) Enable_trigger() IEnable_triggerContext

func (*Ddl_clauseContext) EnterRule

func (s *Ddl_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Ddl_clauseContext) ExitRule

func (s *Ddl_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Ddl_clauseContext) GetParser

func (s *Ddl_clauseContext) GetParser() antlr.Parser

func (*Ddl_clauseContext) GetRuleContext

func (s *Ddl_clauseContext) GetRuleContext() antlr.RuleContext

func (*Ddl_clauseContext) IsDdl_clauseContext

func (*Ddl_clauseContext) IsDdl_clauseContext()

func (*Ddl_clauseContext) Lock_table

func (s *Ddl_clauseContext) Lock_table() ILock_tableContext

func (*Ddl_clauseContext) ToStringTree

func (s *Ddl_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Ddl_clauseContext) Truncate_table

func (s *Ddl_clauseContext) Truncate_table() ITruncate_tableContext

func (*Ddl_clauseContext) Update_statistics

func (s *Ddl_clauseContext) Update_statistics() IUpdate_statisticsContext

type Ddl_objectContext

type Ddl_objectContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDdl_objectContext

func NewDdl_objectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ddl_objectContext

func NewEmptyDdl_objectContext

func NewEmptyDdl_objectContext() *Ddl_objectContext

func (*Ddl_objectContext) EnterRule

func (s *Ddl_objectContext) EnterRule(listener antlr.ParseTreeListener)

func (*Ddl_objectContext) ExitRule

func (s *Ddl_objectContext) ExitRule(listener antlr.ParseTreeListener)

func (*Ddl_objectContext) Full_table_name

func (s *Ddl_objectContext) Full_table_name() IFull_table_nameContext

func (*Ddl_objectContext) GetParser

func (s *Ddl_objectContext) GetParser() antlr.Parser

func (*Ddl_objectContext) GetRuleContext

func (s *Ddl_objectContext) GetRuleContext() antlr.RuleContext

func (*Ddl_objectContext) IsDdl_objectContext

func (*Ddl_objectContext) IsDdl_objectContext()

func (*Ddl_objectContext) LOCAL_ID

func (s *Ddl_objectContext) LOCAL_ID() antlr.TerminalNode

func (*Ddl_objectContext) ToStringTree

func (s *Ddl_objectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Ddl_trigger_operationContext

type Ddl_trigger_operationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDdl_trigger_operationContext

func NewDdl_trigger_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ddl_trigger_operationContext

func NewEmptyDdl_trigger_operationContext

func NewEmptyDdl_trigger_operationContext() *Ddl_trigger_operationContext

func (*Ddl_trigger_operationContext) EnterRule

func (s *Ddl_trigger_operationContext) EnterRule(listener antlr.ParseTreeListener)

func (*Ddl_trigger_operationContext) ExitRule

func (*Ddl_trigger_operationContext) GetParser

func (s *Ddl_trigger_operationContext) GetParser() antlr.Parser

func (*Ddl_trigger_operationContext) GetRuleContext

func (s *Ddl_trigger_operationContext) GetRuleContext() antlr.RuleContext

func (*Ddl_trigger_operationContext) IsDdl_trigger_operationContext

func (*Ddl_trigger_operationContext) IsDdl_trigger_operationContext()

func (*Ddl_trigger_operationContext) Simple_id

func (*Ddl_trigger_operationContext) ToStringTree

func (s *Ddl_trigger_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Declare_cursorContext

type Declare_cursorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeclare_cursorContext

func NewDeclare_cursorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_cursorContext

func NewEmptyDeclare_cursorContext

func NewEmptyDeclare_cursorContext() *Declare_cursorContext

func (*Declare_cursorContext) AllFOR

func (*Declare_cursorContext) CURSOR

func (*Declare_cursorContext) Column_name_list

func (s *Declare_cursorContext) Column_name_list() IColumn_name_listContext

func (*Declare_cursorContext) Cursor_name

func (s *Declare_cursorContext) Cursor_name() ICursor_nameContext

func (*Declare_cursorContext) DECLARE

func (*Declare_cursorContext) Declare_set_cursor_common

func (s *Declare_cursorContext) Declare_set_cursor_common() IDeclare_set_cursor_commonContext

func (*Declare_cursorContext) EnterRule

func (s *Declare_cursorContext) EnterRule(listener antlr.ParseTreeListener)

func (*Declare_cursorContext) ExitRule

func (s *Declare_cursorContext) ExitRule(listener antlr.ParseTreeListener)

func (*Declare_cursorContext) FOR

func (*Declare_cursorContext) GetParser

func (s *Declare_cursorContext) GetParser() antlr.Parser

func (*Declare_cursorContext) GetRuleContext

func (s *Declare_cursorContext) GetRuleContext() antlr.RuleContext

func (*Declare_cursorContext) INSENSITIVE

func (s *Declare_cursorContext) INSENSITIVE() antlr.TerminalNode

func (*Declare_cursorContext) IsDeclare_cursorContext

func (*Declare_cursorContext) IsDeclare_cursorContext()

func (*Declare_cursorContext) OF

func (*Declare_cursorContext) ONLY

func (*Declare_cursorContext) READ

func (*Declare_cursorContext) SCROLL

func (*Declare_cursorContext) SEMI

func (*Declare_cursorContext) SEMI_SENSITIVE

func (s *Declare_cursorContext) SEMI_SENSITIVE() antlr.TerminalNode

func (*Declare_cursorContext) Select_statement

func (s *Declare_cursorContext) Select_statement() ISelect_statementContext

func (*Declare_cursorContext) ToStringTree

func (s *Declare_cursorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Declare_cursorContext) UPDATE

type Declare_localContext

type Declare_localContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeclare_localContext

func NewDeclare_localContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_localContext

func NewEmptyDeclare_localContext

func NewEmptyDeclare_localContext() *Declare_localContext

func (*Declare_localContext) AS

func (*Declare_localContext) Data_type

func (s *Declare_localContext) Data_type() IData_typeContext

func (*Declare_localContext) EQUAL

func (*Declare_localContext) EnterRule

func (s *Declare_localContext) EnterRule(listener antlr.ParseTreeListener)

func (*Declare_localContext) ExitRule

func (s *Declare_localContext) ExitRule(listener antlr.ParseTreeListener)

func (*Declare_localContext) Expression

func (s *Declare_localContext) Expression() IExpressionContext

func (*Declare_localContext) GetParser

func (s *Declare_localContext) GetParser() antlr.Parser

func (*Declare_localContext) GetRuleContext

func (s *Declare_localContext) GetRuleContext() antlr.RuleContext

func (*Declare_localContext) IsDeclare_localContext

func (*Declare_localContext) IsDeclare_localContext()

func (*Declare_localContext) LOCAL_ID

func (s *Declare_localContext) LOCAL_ID() antlr.TerminalNode

func (*Declare_localContext) ToStringTree

func (s *Declare_localContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Declare_set_cursor_commonContext

type Declare_set_cursor_commonContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeclare_set_cursor_commonContext

func NewDeclare_set_cursor_commonContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_set_cursor_commonContext

func NewEmptyDeclare_set_cursor_commonContext

func NewEmptyDeclare_set_cursor_commonContext() *Declare_set_cursor_commonContext

func (*Declare_set_cursor_commonContext) AllDeclare_set_cursor_common_partial

func (s *Declare_set_cursor_commonContext) AllDeclare_set_cursor_common_partial() []IDeclare_set_cursor_common_partialContext

func (*Declare_set_cursor_commonContext) Declare_set_cursor_common_partial

func (s *Declare_set_cursor_commonContext) Declare_set_cursor_common_partial(i int) IDeclare_set_cursor_common_partialContext

func (*Declare_set_cursor_commonContext) EnterRule

func (*Declare_set_cursor_commonContext) ExitRule

func (*Declare_set_cursor_commonContext) FOR

func (*Declare_set_cursor_commonContext) GetParser

func (*Declare_set_cursor_commonContext) GetRuleContext

func (*Declare_set_cursor_commonContext) IsDeclare_set_cursor_commonContext

func (*Declare_set_cursor_commonContext) IsDeclare_set_cursor_commonContext()

func (*Declare_set_cursor_commonContext) Select_statement

func (*Declare_set_cursor_commonContext) ToStringTree

func (s *Declare_set_cursor_commonContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Declare_set_cursor_common_partialContext

type Declare_set_cursor_common_partialContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeclare_set_cursor_common_partialContext

func NewDeclare_set_cursor_common_partialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_set_cursor_common_partialContext

func NewEmptyDeclare_set_cursor_common_partialContext

func NewEmptyDeclare_set_cursor_common_partialContext() *Declare_set_cursor_common_partialContext

func (*Declare_set_cursor_common_partialContext) DYNAMIC

func (*Declare_set_cursor_common_partialContext) EnterRule

func (*Declare_set_cursor_common_partialContext) ExitRule

func (*Declare_set_cursor_common_partialContext) FAST_FORWARD

func (*Declare_set_cursor_common_partialContext) FORWARD_ONLY

func (*Declare_set_cursor_common_partialContext) GLOBAL

func (*Declare_set_cursor_common_partialContext) GetParser

func (*Declare_set_cursor_common_partialContext) GetRuleContext

func (*Declare_set_cursor_common_partialContext) IsDeclare_set_cursor_common_partialContext

func (*Declare_set_cursor_common_partialContext) IsDeclare_set_cursor_common_partialContext()

func (*Declare_set_cursor_common_partialContext) KEYSET

func (*Declare_set_cursor_common_partialContext) LOCAL

func (*Declare_set_cursor_common_partialContext) OPTIMISTIC

func (*Declare_set_cursor_common_partialContext) READ_ONLY

func (*Declare_set_cursor_common_partialContext) SCROLL

func (*Declare_set_cursor_common_partialContext) SCROLL_LOCKS

func (*Declare_set_cursor_common_partialContext) STATIC

func (*Declare_set_cursor_common_partialContext) TYPE_WARNING

func (*Declare_set_cursor_common_partialContext) ToStringTree

func (s *Declare_set_cursor_common_partialContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Declare_statementContext

type Declare_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDeclare_statementContext

func NewDeclare_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_statementContext

func NewEmptyDeclare_statementContext

func NewEmptyDeclare_statementContext() *Declare_statementContext

func (*Declare_statementContext) AS

func (*Declare_statementContext) AllCOMMA

func (*Declare_statementContext) AllDeclare_local

func (s *Declare_statementContext) AllDeclare_local() []IDeclare_localContext

func (*Declare_statementContext) COMMA

func (*Declare_statementContext) DECLARE

func (*Declare_statementContext) Declare_local

func (*Declare_statementContext) EnterRule

func (s *Declare_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Declare_statementContext) ExitRule

func (s *Declare_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Declare_statementContext) GetParser

func (s *Declare_statementContext) GetParser() antlr.Parser

func (*Declare_statementContext) GetRuleContext

func (s *Declare_statementContext) GetRuleContext() antlr.RuleContext

func (*Declare_statementContext) GetXml_namespace_uri

func (s *Declare_statementContext) GetXml_namespace_uri() antlr.Token

func (*Declare_statementContext) Id

func (*Declare_statementContext) IsDeclare_statementContext

func (*Declare_statementContext) IsDeclare_statementContext()

func (*Declare_statementContext) LOCAL_ID

func (*Declare_statementContext) LR_BRACKET

func (*Declare_statementContext) RR_BRACKET

func (*Declare_statementContext) SEMI

func (*Declare_statementContext) STRING

func (*Declare_statementContext) SetXml_namespace_uri

func (s *Declare_statementContext) SetXml_namespace_uri(v antlr.Token)

func (*Declare_statementContext) Table_type_definition

func (s *Declare_statementContext) Table_type_definition() ITable_type_definitionContext

func (*Declare_statementContext) ToStringTree

func (s *Declare_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Declare_statementContext) WITH

func (*Declare_statementContext) XMLNAMESPACES

func (s *Declare_statementContext) XMLNAMESPACES() antlr.TerminalNode

func (*Declare_statementContext) Xml_type_definition

func (s *Declare_statementContext) Xml_type_definition() IXml_type_definitionContext

type Decryption_mechanismContext

type Decryption_mechanismContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDecryption_mechanismContext

func NewDecryption_mechanismContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decryption_mechanismContext

func NewEmptyDecryption_mechanismContext

func NewEmptyDecryption_mechanismContext() *Decryption_mechanismContext

func (*Decryption_mechanismContext) ASYMMETRIC

func (*Decryption_mechanismContext) CERTIFICATE

func (*Decryption_mechanismContext) EQUAL

func (*Decryption_mechanismContext) EnterRule

func (s *Decryption_mechanismContext) EnterRule(listener antlr.ParseTreeListener)

func (*Decryption_mechanismContext) ExitRule

func (s *Decryption_mechanismContext) ExitRule(listener antlr.ParseTreeListener)

func (*Decryption_mechanismContext) GetAsym_key_name

func (s *Decryption_mechanismContext) GetAsym_key_name() IIdContext

func (*Decryption_mechanismContext) GetCertificate_name

func (s *Decryption_mechanismContext) GetCertificate_name() IIdContext

func (*Decryption_mechanismContext) GetDecrypting_Key_name

func (s *Decryption_mechanismContext) GetDecrypting_Key_name() IIdContext

func (*Decryption_mechanismContext) GetParser

func (s *Decryption_mechanismContext) GetParser() antlr.Parser

func (*Decryption_mechanismContext) GetRuleContext

func (s *Decryption_mechanismContext) GetRuleContext() antlr.RuleContext

func (*Decryption_mechanismContext) Id

func (*Decryption_mechanismContext) IsDecryption_mechanismContext

func (*Decryption_mechanismContext) IsDecryption_mechanismContext()

func (*Decryption_mechanismContext) KEY

func (*Decryption_mechanismContext) PASSWORD

func (*Decryption_mechanismContext) STRING

func (*Decryption_mechanismContext) SYMMETRIC

func (*Decryption_mechanismContext) SetAsym_key_name

func (s *Decryption_mechanismContext) SetAsym_key_name(v IIdContext)

func (*Decryption_mechanismContext) SetCertificate_name

func (s *Decryption_mechanismContext) SetCertificate_name(v IIdContext)

func (*Decryption_mechanismContext) SetDecrypting_Key_name

func (s *Decryption_mechanismContext) SetDecrypting_Key_name(v IIdContext)

func (*Decryption_mechanismContext) ToStringTree

func (s *Decryption_mechanismContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Decryption_mechanismContext) WITH

type Default_valueContext

type Default_valueContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDefault_valueContext

func NewDefault_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_valueContext

func NewEmptyDefault_valueContext

func NewEmptyDefault_valueContext() *Default_valueContext

func (*Default_valueContext) Constant

func (s *Default_valueContext) Constant() IConstantContext

func (*Default_valueContext) DEFAULT

func (*Default_valueContext) EnterRule

func (s *Default_valueContext) EnterRule(listener antlr.ParseTreeListener)

func (*Default_valueContext) ExitRule

func (s *Default_valueContext) ExitRule(listener antlr.ParseTreeListener)

func (*Default_valueContext) GetParser

func (s *Default_valueContext) GetParser() antlr.Parser

func (*Default_valueContext) GetRuleContext

func (s *Default_valueContext) GetRuleContext() antlr.RuleContext

func (*Default_valueContext) IsDefault_valueContext

func (*Default_valueContext) IsDefault_valueContext()

func (*Default_valueContext) NULL

func (*Default_valueContext) ToStringTree

func (s *Default_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Delayed_durability_optionContext

type Delayed_durability_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDelayed_durability_optionContext

func NewDelayed_durability_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delayed_durability_optionContext

func NewEmptyDelayed_durability_optionContext

func NewEmptyDelayed_durability_optionContext() *Delayed_durability_optionContext

func (*Delayed_durability_optionContext) ALLOWED

func (*Delayed_durability_optionContext) DELAYED_DURABILITY

func (s *Delayed_durability_optionContext) DELAYED_DURABILITY() antlr.TerminalNode

func (*Delayed_durability_optionContext) DISABLED

func (*Delayed_durability_optionContext) EQUAL

func (*Delayed_durability_optionContext) EnterRule

func (*Delayed_durability_optionContext) ExitRule

func (*Delayed_durability_optionContext) FORCED

func (*Delayed_durability_optionContext) GetParser

func (*Delayed_durability_optionContext) GetRuleContext

func (*Delayed_durability_optionContext) IsDelayed_durability_optionContext

func (*Delayed_durability_optionContext) IsDelayed_durability_optionContext()

func (*Delayed_durability_optionContext) ToStringTree

func (s *Delayed_durability_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Delete_statementContext

type Delete_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDelete_statementContext

func NewDelete_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_statementContext

func NewEmptyDelete_statementContext

func NewEmptyDelete_statementContext() *Delete_statementContext

func (*Delete_statementContext) AllFROM

func (*Delete_statementContext) CURRENT

func (*Delete_statementContext) Cursor_name

func (*Delete_statementContext) DECIMAL

func (*Delete_statementContext) DELETE

func (*Delete_statementContext) Delete_statement_from

func (s *Delete_statementContext) Delete_statement_from() IDelete_statement_fromContext

func (*Delete_statementContext) EnterRule

func (s *Delete_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Delete_statementContext) ExitRule

func (s *Delete_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Delete_statementContext) Expression

func (*Delete_statementContext) FROM

func (*Delete_statementContext) For_clause

func (*Delete_statementContext) GLOBAL

func (*Delete_statementContext) GetCursor_var

func (s *Delete_statementContext) GetCursor_var() antlr.Token

func (*Delete_statementContext) GetParser

func (s *Delete_statementContext) GetParser() antlr.Parser

func (*Delete_statementContext) GetRuleContext

func (s *Delete_statementContext) GetRuleContext() antlr.RuleContext

func (*Delete_statementContext) Insert_with_table_hints

func (s *Delete_statementContext) Insert_with_table_hints() IInsert_with_table_hintsContext

func (*Delete_statementContext) IsDelete_statementContext

func (*Delete_statementContext) IsDelete_statementContext()

func (*Delete_statementContext) LOCAL_ID

func (*Delete_statementContext) LR_BRACKET

func (s *Delete_statementContext) LR_BRACKET() antlr.TerminalNode

func (*Delete_statementContext) OF

func (*Delete_statementContext) Option_clause

func (*Delete_statementContext) Output_clause

func (*Delete_statementContext) PERCENT

func (*Delete_statementContext) RR_BRACKET

func (s *Delete_statementContext) RR_BRACKET() antlr.TerminalNode

func (*Delete_statementContext) SEMI

func (*Delete_statementContext) Search_condition

func (s *Delete_statementContext) Search_condition() ISearch_conditionContext

func (*Delete_statementContext) SetCursor_var

func (s *Delete_statementContext) SetCursor_var(v antlr.Token)

func (*Delete_statementContext) TOP

func (*Delete_statementContext) Table_sources

func (*Delete_statementContext) ToStringTree

func (s *Delete_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Delete_statementContext) WHERE

func (*Delete_statementContext) With_expression

func (s *Delete_statementContext) With_expression() IWith_expressionContext

type Delete_statement_fromContext

type Delete_statement_fromContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDelete_statement_fromContext

func NewDelete_statement_fromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_statement_fromContext

func NewEmptyDelete_statement_fromContext

func NewEmptyDelete_statement_fromContext() *Delete_statement_fromContext

func (*Delete_statement_fromContext) Ddl_object

func (*Delete_statement_fromContext) EnterRule

func (s *Delete_statement_fromContext) EnterRule(listener antlr.ParseTreeListener)

func (*Delete_statement_fromContext) ExitRule

func (*Delete_statement_fromContext) GetParser

func (s *Delete_statement_fromContext) GetParser() antlr.Parser

func (*Delete_statement_fromContext) GetRuleContext

func (s *Delete_statement_fromContext) GetRuleContext() antlr.RuleContext

func (*Delete_statement_fromContext) GetTable_var

func (s *Delete_statement_fromContext) GetTable_var() antlr.Token

func (*Delete_statement_fromContext) IsDelete_statement_fromContext

func (*Delete_statement_fromContext) IsDelete_statement_fromContext()

func (*Delete_statement_fromContext) LOCAL_ID

func (*Delete_statement_fromContext) Rowset_function_limited

func (*Delete_statement_fromContext) SetTable_var

func (s *Delete_statement_fromContext) SetTable_var(v antlr.Token)

func (*Delete_statement_fromContext) Table_alias

func (*Delete_statement_fromContext) ToStringTree

func (s *Delete_statement_fromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Derived_tableContext

type Derived_tableContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDerived_tableContext

func NewDerived_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Derived_tableContext

func NewEmptyDerived_tableContext

func NewEmptyDerived_tableContext() *Derived_tableContext

func (*Derived_tableContext) EnterRule

func (s *Derived_tableContext) EnterRule(listener antlr.ParseTreeListener)

func (*Derived_tableContext) ExitRule

func (s *Derived_tableContext) ExitRule(listener antlr.ParseTreeListener)

func (*Derived_tableContext) GetParser

func (s *Derived_tableContext) GetParser() antlr.Parser

func (*Derived_tableContext) GetRuleContext

func (s *Derived_tableContext) GetRuleContext() antlr.RuleContext

func (*Derived_tableContext) IsDerived_tableContext

func (*Derived_tableContext) IsDerived_tableContext()

func (*Derived_tableContext) LR_BRACKET

func (s *Derived_tableContext) LR_BRACKET() antlr.TerminalNode

func (*Derived_tableContext) RR_BRACKET

func (s *Derived_tableContext) RR_BRACKET() antlr.TerminalNode

func (*Derived_tableContext) Subquery

func (s *Derived_tableContext) Subquery() ISubqueryContext

func (*Derived_tableContext) Table_value_constructor

func (s *Derived_tableContext) Table_value_constructor() ITable_value_constructorContext

func (*Derived_tableContext) ToStringTree

func (s *Derived_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Disable_triggerContext

type Disable_triggerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDisable_triggerContext

func NewDisable_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disable_triggerContext

func NewEmptyDisable_triggerContext

func NewEmptyDisable_triggerContext() *Disable_triggerContext

func (*Disable_triggerContext) ALL

func (*Disable_triggerContext) AllALL

func (*Disable_triggerContext) AllCOMMA

func (s *Disable_triggerContext) AllCOMMA() []antlr.TerminalNode

func (*Disable_triggerContext) AllDOT

func (*Disable_triggerContext) AllId

func (s *Disable_triggerContext) AllId() []IIdContext

func (*Disable_triggerContext) COMMA

func (*Disable_triggerContext) DATABASE

func (*Disable_triggerContext) DISABLE

func (*Disable_triggerContext) DOT

func (*Disable_triggerContext) EnterRule

func (s *Disable_triggerContext) EnterRule(listener antlr.ParseTreeListener)

func (*Disable_triggerContext) ExitRule

func (s *Disable_triggerContext) ExitRule(listener antlr.ParseTreeListener)

func (*Disable_triggerContext) GetObject_name

func (s *Disable_triggerContext) GetObject_name() IIdContext

func (*Disable_triggerContext) GetParser

func (s *Disable_triggerContext) GetParser() antlr.Parser

func (*Disable_triggerContext) GetRuleContext

func (s *Disable_triggerContext) GetRuleContext() antlr.RuleContext

func (*Disable_triggerContext) GetSchema_id

func (s *Disable_triggerContext) GetSchema_id() IIdContext

func (*Disable_triggerContext) GetSchema_name

func (s *Disable_triggerContext) GetSchema_name() IIdContext

func (*Disable_triggerContext) GetTrigger_name

func (s *Disable_triggerContext) GetTrigger_name() IIdContext

func (*Disable_triggerContext) Id

func (*Disable_triggerContext) IsDisable_triggerContext

func (*Disable_triggerContext) IsDisable_triggerContext()

func (*Disable_triggerContext) ON

func (*Disable_triggerContext) SERVER

func (*Disable_triggerContext) SetObject_name

func (s *Disable_triggerContext) SetObject_name(v IIdContext)

func (*Disable_triggerContext) SetSchema_id

func (s *Disable_triggerContext) SetSchema_id(v IIdContext)

func (*Disable_triggerContext) SetSchema_name

func (s *Disable_triggerContext) SetSchema_name(v IIdContext)

func (*Disable_triggerContext) SetTrigger_name

func (s *Disable_triggerContext) SetTrigger_name(v IIdContext)

func (*Disable_triggerContext) TRIGGER

func (*Disable_triggerContext) ToStringTree

func (s *Disable_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Dml_clauseContext

type Dml_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDml_clauseContext

func NewDml_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_clauseContext

func NewEmptyDml_clauseContext

func NewEmptyDml_clauseContext() *Dml_clauseContext

func (*Dml_clauseContext) Delete_statement

func (s *Dml_clauseContext) Delete_statement() IDelete_statementContext

func (*Dml_clauseContext) EnterRule

func (s *Dml_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Dml_clauseContext) ExitRule

func (s *Dml_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Dml_clauseContext) GetParser

func (s *Dml_clauseContext) GetParser() antlr.Parser

func (*Dml_clauseContext) GetRuleContext

func (s *Dml_clauseContext) GetRuleContext() antlr.RuleContext

func (*Dml_clauseContext) Insert_statement

func (s *Dml_clauseContext) Insert_statement() IInsert_statementContext

func (*Dml_clauseContext) IsDml_clauseContext

func (*Dml_clauseContext) IsDml_clauseContext()

func (*Dml_clauseContext) Merge_statement

func (s *Dml_clauseContext) Merge_statement() IMerge_statementContext

func (*Dml_clauseContext) Select_statement

func (s *Dml_clauseContext) Select_statement() ISelect_statementContext

func (*Dml_clauseContext) ToStringTree

func (s *Dml_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Dml_clauseContext) Update_statement

func (s *Dml_clauseContext) Update_statement() IUpdate_statementContext

type Dml_trigger_operationContext

type Dml_trigger_operationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDml_trigger_operationContext

func NewDml_trigger_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_trigger_operationContext

func NewEmptyDml_trigger_operationContext

func NewEmptyDml_trigger_operationContext() *Dml_trigger_operationContext

func (*Dml_trigger_operationContext) DELETE

func (*Dml_trigger_operationContext) EnterRule

func (s *Dml_trigger_operationContext) EnterRule(listener antlr.ParseTreeListener)

func (*Dml_trigger_operationContext) ExitRule

func (*Dml_trigger_operationContext) GetParser

func (s *Dml_trigger_operationContext) GetParser() antlr.Parser

func (*Dml_trigger_operationContext) GetRuleContext

func (s *Dml_trigger_operationContext) GetRuleContext() antlr.RuleContext

func (*Dml_trigger_operationContext) INSERT

func (*Dml_trigger_operationContext) IsDml_trigger_operationContext

func (*Dml_trigger_operationContext) IsDml_trigger_operationContext()

func (*Dml_trigger_operationContext) ToStringTree

func (s *Dml_trigger_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Dml_trigger_operationContext) UPDATE

type Dml_trigger_optionContext

type Dml_trigger_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDml_trigger_optionContext

func NewDml_trigger_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_trigger_optionContext

func NewEmptyDml_trigger_optionContext

func NewEmptyDml_trigger_optionContext() *Dml_trigger_optionContext

func (*Dml_trigger_optionContext) ENCRYPTION

func (*Dml_trigger_optionContext) EnterRule

func (s *Dml_trigger_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Dml_trigger_optionContext) Execute_clause

func (*Dml_trigger_optionContext) ExitRule

func (s *Dml_trigger_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Dml_trigger_optionContext) GetParser

func (s *Dml_trigger_optionContext) GetParser() antlr.Parser

func (*Dml_trigger_optionContext) GetRuleContext

func (s *Dml_trigger_optionContext) GetRuleContext() antlr.RuleContext

func (*Dml_trigger_optionContext) IsDml_trigger_optionContext

func (*Dml_trigger_optionContext) IsDml_trigger_optionContext()

func (*Dml_trigger_optionContext) ToStringTree

func (s *Dml_trigger_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_aggregateContext

type Drop_aggregateContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_aggregateContext

func NewDrop_aggregateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_aggregateContext

func NewEmptyDrop_aggregateContext

func NewEmptyDrop_aggregateContext() *Drop_aggregateContext

func (*Drop_aggregateContext) AGGREGATE

func (s *Drop_aggregateContext) AGGREGATE() antlr.TerminalNode

func (*Drop_aggregateContext) AllId

func (s *Drop_aggregateContext) AllId() []IIdContext

func (*Drop_aggregateContext) DOT

func (*Drop_aggregateContext) DROP

func (*Drop_aggregateContext) EXISTS

func (*Drop_aggregateContext) EnterRule

func (s *Drop_aggregateContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_aggregateContext) ExitRule

func (s *Drop_aggregateContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_aggregateContext) GetAggregate_name

func (s *Drop_aggregateContext) GetAggregate_name() IIdContext

func (*Drop_aggregateContext) GetParser

func (s *Drop_aggregateContext) GetParser() antlr.Parser

func (*Drop_aggregateContext) GetRuleContext

func (s *Drop_aggregateContext) GetRuleContext() antlr.RuleContext

func (*Drop_aggregateContext) GetSchema_name

func (s *Drop_aggregateContext) GetSchema_name() IIdContext

func (*Drop_aggregateContext) IF

func (*Drop_aggregateContext) Id

func (*Drop_aggregateContext) IsDrop_aggregateContext

func (*Drop_aggregateContext) IsDrop_aggregateContext()

func (*Drop_aggregateContext) SetAggregate_name

func (s *Drop_aggregateContext) SetAggregate_name(v IIdContext)

func (*Drop_aggregateContext) SetSchema_name

func (s *Drop_aggregateContext) SetSchema_name(v IIdContext)

func (*Drop_aggregateContext) ToStringTree

func (s *Drop_aggregateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_application_roleContext

type Drop_application_roleContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_application_roleContext

func NewDrop_application_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_application_roleContext

func NewEmptyDrop_application_roleContext

func NewEmptyDrop_application_roleContext() *Drop_application_roleContext

func (*Drop_application_roleContext) APPLICATION

func (*Drop_application_roleContext) DROP

func (*Drop_application_roleContext) EnterRule

func (s *Drop_application_roleContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_application_roleContext) ExitRule

func (*Drop_application_roleContext) GetParser

func (s *Drop_application_roleContext) GetParser() antlr.Parser

func (*Drop_application_roleContext) GetRolename

func (s *Drop_application_roleContext) GetRolename() IIdContext

func (*Drop_application_roleContext) GetRuleContext

func (s *Drop_application_roleContext) GetRuleContext() antlr.RuleContext

func (*Drop_application_roleContext) Id

func (*Drop_application_roleContext) IsDrop_application_roleContext

func (*Drop_application_roleContext) IsDrop_application_roleContext()

func (*Drop_application_roleContext) ROLE

func (*Drop_application_roleContext) SetRolename

func (s *Drop_application_roleContext) SetRolename(v IIdContext)

func (*Drop_application_roleContext) ToStringTree

func (s *Drop_application_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_assemblyContext

type Drop_assemblyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_assemblyContext

func NewDrop_assemblyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_assemblyContext

func NewEmptyDrop_assemblyContext

func NewEmptyDrop_assemblyContext() *Drop_assemblyContext

func (*Drop_assemblyContext) ASSEMBLY

func (s *Drop_assemblyContext) ASSEMBLY() antlr.TerminalNode

func (*Drop_assemblyContext) AllCOMMA

func (s *Drop_assemblyContext) AllCOMMA() []antlr.TerminalNode

func (*Drop_assemblyContext) AllId

func (s *Drop_assemblyContext) AllId() []IIdContext

func (*Drop_assemblyContext) COMMA

func (*Drop_assemblyContext) DEPENDENTS

func (s *Drop_assemblyContext) DEPENDENTS() antlr.TerminalNode

func (*Drop_assemblyContext) DROP

func (*Drop_assemblyContext) EXISTS

func (*Drop_assemblyContext) EnterRule

func (s *Drop_assemblyContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_assemblyContext) ExitRule

func (s *Drop_assemblyContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_assemblyContext) GetAssembly_name

func (s *Drop_assemblyContext) GetAssembly_name() IIdContext

func (*Drop_assemblyContext) GetParser

func (s *Drop_assemblyContext) GetParser() antlr.Parser

func (*Drop_assemblyContext) GetRuleContext

func (s *Drop_assemblyContext) GetRuleContext() antlr.RuleContext

func (*Drop_assemblyContext) IF

func (*Drop_assemblyContext) Id

func (*Drop_assemblyContext) IsDrop_assemblyContext

func (*Drop_assemblyContext) IsDrop_assemblyContext()

func (*Drop_assemblyContext) NO

func (*Drop_assemblyContext) SetAssembly_name

func (s *Drop_assemblyContext) SetAssembly_name(v IIdContext)

func (*Drop_assemblyContext) ToStringTree

func (s *Drop_assemblyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Drop_assemblyContext) WITH

type Drop_asymmetric_keyContext

type Drop_asymmetric_keyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_asymmetric_keyContext

func NewDrop_asymmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_asymmetric_keyContext

func NewEmptyDrop_asymmetric_keyContext

func NewEmptyDrop_asymmetric_keyContext() *Drop_asymmetric_keyContext

func (*Drop_asymmetric_keyContext) ASYMMETRIC

func (*Drop_asymmetric_keyContext) AllKEY

func (*Drop_asymmetric_keyContext) DROP

func (*Drop_asymmetric_keyContext) EnterRule

func (s *Drop_asymmetric_keyContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_asymmetric_keyContext) ExitRule

func (s *Drop_asymmetric_keyContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_asymmetric_keyContext) GetKey_name

func (s *Drop_asymmetric_keyContext) GetKey_name() IIdContext

func (*Drop_asymmetric_keyContext) GetParser

func (s *Drop_asymmetric_keyContext) GetParser() antlr.Parser

func (*Drop_asymmetric_keyContext) GetRuleContext

func (s *Drop_asymmetric_keyContext) GetRuleContext() antlr.RuleContext

func (*Drop_asymmetric_keyContext) Id

func (*Drop_asymmetric_keyContext) IsDrop_asymmetric_keyContext

func (*Drop_asymmetric_keyContext) IsDrop_asymmetric_keyContext()

func (*Drop_asymmetric_keyContext) KEY

func (*Drop_asymmetric_keyContext) PROVIDER

func (*Drop_asymmetric_keyContext) REMOVE

func (*Drop_asymmetric_keyContext) SetKey_name

func (s *Drop_asymmetric_keyContext) SetKey_name(v IIdContext)

func (*Drop_asymmetric_keyContext) ToStringTree

func (s *Drop_asymmetric_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_availability_groupContext

type Drop_availability_groupContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_availability_groupContext

func NewDrop_availability_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_availability_groupContext

func NewEmptyDrop_availability_groupContext

func NewEmptyDrop_availability_groupContext() *Drop_availability_groupContext

func (*Drop_availability_groupContext) AVAILABILITY

func (*Drop_availability_groupContext) DROP

func (*Drop_availability_groupContext) EnterRule

func (*Drop_availability_groupContext) ExitRule

func (*Drop_availability_groupContext) GROUP

func (*Drop_availability_groupContext) GetGroup_name

func (s *Drop_availability_groupContext) GetGroup_name() IIdContext

func (*Drop_availability_groupContext) GetParser

func (*Drop_availability_groupContext) GetRuleContext

func (s *Drop_availability_groupContext) GetRuleContext() antlr.RuleContext

func (*Drop_availability_groupContext) Id

func (*Drop_availability_groupContext) IsDrop_availability_groupContext

func (*Drop_availability_groupContext) IsDrop_availability_groupContext()

func (*Drop_availability_groupContext) SetGroup_name

func (s *Drop_availability_groupContext) SetGroup_name(v IIdContext)

func (*Drop_availability_groupContext) ToStringTree

func (s *Drop_availability_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_backward_compatible_indexContext

type Drop_backward_compatible_indexContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_backward_compatible_indexContext

func NewDrop_backward_compatible_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_backward_compatible_indexContext

func NewEmptyDrop_backward_compatible_indexContext

func NewEmptyDrop_backward_compatible_indexContext() *Drop_backward_compatible_indexContext

func (*Drop_backward_compatible_indexContext) AllDOT

func (*Drop_backward_compatible_indexContext) AllId

func (*Drop_backward_compatible_indexContext) DOT

func (*Drop_backward_compatible_indexContext) EnterRule

func (*Drop_backward_compatible_indexContext) ExitRule

func (*Drop_backward_compatible_indexContext) GetIndex_name

func (*Drop_backward_compatible_indexContext) GetOwner_name

func (*Drop_backward_compatible_indexContext) GetParser

func (*Drop_backward_compatible_indexContext) GetRuleContext

func (*Drop_backward_compatible_indexContext) GetTable_or_view_name

func (s *Drop_backward_compatible_indexContext) GetTable_or_view_name() IIdContext

func (*Drop_backward_compatible_indexContext) Id

func (*Drop_backward_compatible_indexContext) IsDrop_backward_compatible_indexContext

func (*Drop_backward_compatible_indexContext) IsDrop_backward_compatible_indexContext()

func (*Drop_backward_compatible_indexContext) SetIndex_name

func (*Drop_backward_compatible_indexContext) SetOwner_name

func (*Drop_backward_compatible_indexContext) SetTable_or_view_name

func (s *Drop_backward_compatible_indexContext) SetTable_or_view_name(v IIdContext)

func (*Drop_backward_compatible_indexContext) ToStringTree

func (s *Drop_backward_compatible_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_broker_priorityContext

type Drop_broker_priorityContext struct {
	*antlr.BaseParserRuleContext

	ConversationPriorityName IIdContext
	// contains filtered or unexported fields
}

func NewDrop_broker_priorityContext

func NewDrop_broker_priorityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_broker_priorityContext

func NewEmptyDrop_broker_priorityContext

func NewEmptyDrop_broker_priorityContext() *Drop_broker_priorityContext

func (*Drop_broker_priorityContext) BROKER

func (*Drop_broker_priorityContext) DROP

func (*Drop_broker_priorityContext) EnterRule

func (s *Drop_broker_priorityContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_broker_priorityContext) ExitRule

func (s *Drop_broker_priorityContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_broker_priorityContext) GetConversationPriorityName

func (s *Drop_broker_priorityContext) GetConversationPriorityName() IIdContext

func (*Drop_broker_priorityContext) GetParser

func (s *Drop_broker_priorityContext) GetParser() antlr.Parser

func (*Drop_broker_priorityContext) GetRuleContext

func (s *Drop_broker_priorityContext) GetRuleContext() antlr.RuleContext

func (*Drop_broker_priorityContext) Id

func (*Drop_broker_priorityContext) IsDrop_broker_priorityContext

func (*Drop_broker_priorityContext) IsDrop_broker_priorityContext()

func (*Drop_broker_priorityContext) PRIORITY

func (*Drop_broker_priorityContext) SetConversationPriorityName

func (s *Drop_broker_priorityContext) SetConversationPriorityName(v IIdContext)

func (*Drop_broker_priorityContext) ToStringTree

func (s *Drop_broker_priorityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_certificateContext

type Drop_certificateContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_certificateContext

func NewDrop_certificateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_certificateContext

func NewEmptyDrop_certificateContext

func NewEmptyDrop_certificateContext() *Drop_certificateContext

func (*Drop_certificateContext) CERTIFICATE

func (s *Drop_certificateContext) CERTIFICATE() antlr.TerminalNode

func (*Drop_certificateContext) DROP

func (*Drop_certificateContext) EnterRule

func (s *Drop_certificateContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_certificateContext) ExitRule

func (s *Drop_certificateContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_certificateContext) GetCertificate_name

func (s *Drop_certificateContext) GetCertificate_name() IIdContext

func (*Drop_certificateContext) GetParser

func (s *Drop_certificateContext) GetParser() antlr.Parser

func (*Drop_certificateContext) GetRuleContext

func (s *Drop_certificateContext) GetRuleContext() antlr.RuleContext

func (*Drop_certificateContext) Id

func (*Drop_certificateContext) IsDrop_certificateContext

func (*Drop_certificateContext) IsDrop_certificateContext()

func (*Drop_certificateContext) SetCertificate_name

func (s *Drop_certificateContext) SetCertificate_name(v IIdContext)

func (*Drop_certificateContext) ToStringTree

func (s *Drop_certificateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_column_encryption_keyContext

type Drop_column_encryption_keyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_column_encryption_keyContext

func NewDrop_column_encryption_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_column_encryption_keyContext

func NewEmptyDrop_column_encryption_keyContext

func NewEmptyDrop_column_encryption_keyContext() *Drop_column_encryption_keyContext

func (*Drop_column_encryption_keyContext) COLUMN

func (*Drop_column_encryption_keyContext) DROP

func (*Drop_column_encryption_keyContext) ENCRYPTION

func (*Drop_column_encryption_keyContext) EnterRule

func (*Drop_column_encryption_keyContext) ExitRule

func (*Drop_column_encryption_keyContext) GetKey_name

func (*Drop_column_encryption_keyContext) GetParser

func (*Drop_column_encryption_keyContext) GetRuleContext

func (*Drop_column_encryption_keyContext) Id

func (*Drop_column_encryption_keyContext) IsDrop_column_encryption_keyContext

func (*Drop_column_encryption_keyContext) IsDrop_column_encryption_keyContext()

func (*Drop_column_encryption_keyContext) KEY

func (*Drop_column_encryption_keyContext) SetKey_name

func (*Drop_column_encryption_keyContext) ToStringTree

func (s *Drop_column_encryption_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_column_master_keyContext

type Drop_column_master_keyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_column_master_keyContext

func NewDrop_column_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_column_master_keyContext

func NewEmptyDrop_column_master_keyContext

func NewEmptyDrop_column_master_keyContext() *Drop_column_master_keyContext

func (*Drop_column_master_keyContext) COLUMN

func (*Drop_column_master_keyContext) DROP

func (*Drop_column_master_keyContext) EnterRule

func (s *Drop_column_master_keyContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_column_master_keyContext) ExitRule

func (*Drop_column_master_keyContext) GetKey_name

func (s *Drop_column_master_keyContext) GetKey_name() IIdContext

func (*Drop_column_master_keyContext) GetParser

func (*Drop_column_master_keyContext) GetRuleContext

func (s *Drop_column_master_keyContext) GetRuleContext() antlr.RuleContext

func (*Drop_column_master_keyContext) Id

func (*Drop_column_master_keyContext) IsDrop_column_master_keyContext

func (*Drop_column_master_keyContext) IsDrop_column_master_keyContext()

func (*Drop_column_master_keyContext) KEY

func (*Drop_column_master_keyContext) MASTER

func (*Drop_column_master_keyContext) SetKey_name

func (s *Drop_column_master_keyContext) SetKey_name(v IIdContext)

func (*Drop_column_master_keyContext) ToStringTree

func (s *Drop_column_master_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_contractContext

type Drop_contractContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_contractContext

func NewDrop_contractContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_contractContext

func NewEmptyDrop_contractContext

func NewEmptyDrop_contractContext() *Drop_contractContext

func (*Drop_contractContext) CONTRACT

func (s *Drop_contractContext) CONTRACT() antlr.TerminalNode

func (*Drop_contractContext) DROP

func (*Drop_contractContext) EnterRule

func (s *Drop_contractContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_contractContext) ExitRule

func (s *Drop_contractContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_contractContext) GetDropped_contract_name

func (s *Drop_contractContext) GetDropped_contract_name() IIdContext

func (*Drop_contractContext) GetParser

func (s *Drop_contractContext) GetParser() antlr.Parser

func (*Drop_contractContext) GetRuleContext

func (s *Drop_contractContext) GetRuleContext() antlr.RuleContext

func (*Drop_contractContext) Id

func (*Drop_contractContext) IsDrop_contractContext

func (*Drop_contractContext) IsDrop_contractContext()

func (*Drop_contractContext) SetDropped_contract_name

func (s *Drop_contractContext) SetDropped_contract_name(v IIdContext)

func (*Drop_contractContext) ToStringTree

func (s *Drop_contractContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_credentialContext

type Drop_credentialContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_credentialContext

func NewDrop_credentialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_credentialContext

func NewEmptyDrop_credentialContext

func NewEmptyDrop_credentialContext() *Drop_credentialContext

func (*Drop_credentialContext) CREDENTIAL

func (s *Drop_credentialContext) CREDENTIAL() antlr.TerminalNode

func (*Drop_credentialContext) DROP

func (*Drop_credentialContext) EnterRule

func (s *Drop_credentialContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_credentialContext) ExitRule

func (s *Drop_credentialContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_credentialContext) GetCredential_name

func (s *Drop_credentialContext) GetCredential_name() IIdContext

func (*Drop_credentialContext) GetParser

func (s *Drop_credentialContext) GetParser() antlr.Parser

func (*Drop_credentialContext) GetRuleContext

func (s *Drop_credentialContext) GetRuleContext() antlr.RuleContext

func (*Drop_credentialContext) Id

func (*Drop_credentialContext) IsDrop_credentialContext

func (*Drop_credentialContext) IsDrop_credentialContext()

func (*Drop_credentialContext) SetCredential_name

func (s *Drop_credentialContext) SetCredential_name(v IIdContext)

func (*Drop_credentialContext) ToStringTree

func (s *Drop_credentialContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_cryptograhic_providerContext

type Drop_cryptograhic_providerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_cryptograhic_providerContext

func NewDrop_cryptograhic_providerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_cryptograhic_providerContext

func NewEmptyDrop_cryptograhic_providerContext

func NewEmptyDrop_cryptograhic_providerContext() *Drop_cryptograhic_providerContext

func (*Drop_cryptograhic_providerContext) CRYPTOGRAPHIC

func (*Drop_cryptograhic_providerContext) DROP

func (*Drop_cryptograhic_providerContext) EnterRule

func (*Drop_cryptograhic_providerContext) ExitRule

func (*Drop_cryptograhic_providerContext) GetParser

func (*Drop_cryptograhic_providerContext) GetProvider_name

func (s *Drop_cryptograhic_providerContext) GetProvider_name() IIdContext

func (*Drop_cryptograhic_providerContext) GetRuleContext

func (*Drop_cryptograhic_providerContext) Id

func (*Drop_cryptograhic_providerContext) IsDrop_cryptograhic_providerContext

func (*Drop_cryptograhic_providerContext) IsDrop_cryptograhic_providerContext()

func (*Drop_cryptograhic_providerContext) PROVIDER

func (*Drop_cryptograhic_providerContext) SetProvider_name

func (s *Drop_cryptograhic_providerContext) SetProvider_name(v IIdContext)

func (*Drop_cryptograhic_providerContext) ToStringTree

func (s *Drop_cryptograhic_providerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_databaseContext

type Drop_databaseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_databaseContext

func NewDrop_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_databaseContext

func NewEmptyDrop_databaseContext

func NewEmptyDrop_databaseContext() *Drop_databaseContext

func (*Drop_databaseContext) AllCOMMA

func (s *Drop_databaseContext) AllCOMMA() []antlr.TerminalNode

func (*Drop_databaseContext) AllId

func (s *Drop_databaseContext) AllId() []IIdContext

func (*Drop_databaseContext) COMMA

func (*Drop_databaseContext) DATABASE

func (s *Drop_databaseContext) DATABASE() antlr.TerminalNode

func (*Drop_databaseContext) DROP

func (*Drop_databaseContext) EXISTS

func (*Drop_databaseContext) EnterRule

func (s *Drop_databaseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_databaseContext) ExitRule

func (s *Drop_databaseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_databaseContext) GetDatabase_name_or_database_snapshot_name

func (s *Drop_databaseContext) GetDatabase_name_or_database_snapshot_name() IIdContext

func (*Drop_databaseContext) GetParser

func (s *Drop_databaseContext) GetParser() antlr.Parser

func (*Drop_databaseContext) GetRuleContext

func (s *Drop_databaseContext) GetRuleContext() antlr.RuleContext

func (*Drop_databaseContext) IF

func (*Drop_databaseContext) Id

func (*Drop_databaseContext) IsDrop_databaseContext

func (*Drop_databaseContext) IsDrop_databaseContext()

func (*Drop_databaseContext) SetDatabase_name_or_database_snapshot_name

func (s *Drop_databaseContext) SetDatabase_name_or_database_snapshot_name(v IIdContext)

func (*Drop_databaseContext) ToStringTree

func (s *Drop_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_database_audit_specificationContext

type Drop_database_audit_specificationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_database_audit_specificationContext

func NewDrop_database_audit_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_database_audit_specificationContext

func NewEmptyDrop_database_audit_specificationContext

func NewEmptyDrop_database_audit_specificationContext() *Drop_database_audit_specificationContext

func (*Drop_database_audit_specificationContext) AUDIT

func (*Drop_database_audit_specificationContext) DATABASE

func (*Drop_database_audit_specificationContext) DROP

func (*Drop_database_audit_specificationContext) EnterRule

func (*Drop_database_audit_specificationContext) ExitRule

func (*Drop_database_audit_specificationContext) GetAudit_specification_name

func (s *Drop_database_audit_specificationContext) GetAudit_specification_name() IIdContext

func (*Drop_database_audit_specificationContext) GetParser

func (*Drop_database_audit_specificationContext) GetRuleContext

func (*Drop_database_audit_specificationContext) Id

func (*Drop_database_audit_specificationContext) IsDrop_database_audit_specificationContext

func (*Drop_database_audit_specificationContext) IsDrop_database_audit_specificationContext()

func (*Drop_database_audit_specificationContext) SPECIFICATION

func (*Drop_database_audit_specificationContext) SetAudit_specification_name

func (s *Drop_database_audit_specificationContext) SetAudit_specification_name(v IIdContext)

func (*Drop_database_audit_specificationContext) ToStringTree

func (s *Drop_database_audit_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_database_scoped_credentialContext

type Drop_database_scoped_credentialContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_database_scoped_credentialContext

func NewDrop_database_scoped_credentialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_database_scoped_credentialContext

func NewEmptyDrop_database_scoped_credentialContext

func NewEmptyDrop_database_scoped_credentialContext() *Drop_database_scoped_credentialContext

func (*Drop_database_scoped_credentialContext) CREDENTIAL

func (*Drop_database_scoped_credentialContext) DATABASE

func (*Drop_database_scoped_credentialContext) DROP

func (*Drop_database_scoped_credentialContext) EnterRule

func (*Drop_database_scoped_credentialContext) ExitRule

func (*Drop_database_scoped_credentialContext) GetCredential_name

func (s *Drop_database_scoped_credentialContext) GetCredential_name() IIdContext

func (*Drop_database_scoped_credentialContext) GetParser

func (*Drop_database_scoped_credentialContext) GetRuleContext

func (*Drop_database_scoped_credentialContext) Id

func (*Drop_database_scoped_credentialContext) IsDrop_database_scoped_credentialContext

func (*Drop_database_scoped_credentialContext) IsDrop_database_scoped_credentialContext()

func (*Drop_database_scoped_credentialContext) SCOPED

func (*Drop_database_scoped_credentialContext) SetCredential_name

func (s *Drop_database_scoped_credentialContext) SetCredential_name(v IIdContext)

func (*Drop_database_scoped_credentialContext) ToStringTree

func (s *Drop_database_scoped_credentialContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_db_roleContext

type Drop_db_roleContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_db_roleContext

func NewDrop_db_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_db_roleContext

func NewEmptyDrop_db_roleContext

func NewEmptyDrop_db_roleContext() *Drop_db_roleContext

func (*Drop_db_roleContext) DROP

func (*Drop_db_roleContext) EXISTS

func (*Drop_db_roleContext) EnterRule

func (s *Drop_db_roleContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_db_roleContext) ExitRule

func (s *Drop_db_roleContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_db_roleContext) GetParser

func (s *Drop_db_roleContext) GetParser() antlr.Parser

func (*Drop_db_roleContext) GetRole_name

func (s *Drop_db_roleContext) GetRole_name() IIdContext

func (*Drop_db_roleContext) GetRuleContext

func (s *Drop_db_roleContext) GetRuleContext() antlr.RuleContext

func (*Drop_db_roleContext) IF

func (*Drop_db_roleContext) Id

func (*Drop_db_roleContext) IsDrop_db_roleContext

func (*Drop_db_roleContext) IsDrop_db_roleContext()

func (*Drop_db_roleContext) ROLE

func (*Drop_db_roleContext) SetRole_name

func (s *Drop_db_roleContext) SetRole_name(v IIdContext)

func (*Drop_db_roleContext) ToStringTree

func (s *Drop_db_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_ddl_triggerContext

type Drop_ddl_triggerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_ddl_triggerContext

func NewDrop_ddl_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_ddl_triggerContext

func NewEmptyDrop_ddl_triggerContext

func NewEmptyDrop_ddl_triggerContext() *Drop_ddl_triggerContext

func (*Drop_ddl_triggerContext) ALL

func (*Drop_ddl_triggerContext) AllCOMMA

func (s *Drop_ddl_triggerContext) AllCOMMA() []antlr.TerminalNode

func (*Drop_ddl_triggerContext) AllSimple_name

func (s *Drop_ddl_triggerContext) AllSimple_name() []ISimple_nameContext

func (*Drop_ddl_triggerContext) COMMA

func (*Drop_ddl_triggerContext) DATABASE

func (*Drop_ddl_triggerContext) DROP

func (*Drop_ddl_triggerContext) EXISTS

func (*Drop_ddl_triggerContext) EnterRule

func (s *Drop_ddl_triggerContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_ddl_triggerContext) ExitRule

func (s *Drop_ddl_triggerContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_ddl_triggerContext) GetParser

func (s *Drop_ddl_triggerContext) GetParser() antlr.Parser

func (*Drop_ddl_triggerContext) GetRuleContext

func (s *Drop_ddl_triggerContext) GetRuleContext() antlr.RuleContext

func (*Drop_ddl_triggerContext) IF

func (*Drop_ddl_triggerContext) IsDrop_ddl_triggerContext

func (*Drop_ddl_triggerContext) IsDrop_ddl_triggerContext()

func (*Drop_ddl_triggerContext) ON

func (*Drop_ddl_triggerContext) SEMI

func (*Drop_ddl_triggerContext) SERVER

func (*Drop_ddl_triggerContext) Simple_name

func (*Drop_ddl_triggerContext) TRIGGER

func (*Drop_ddl_triggerContext) ToStringTree

func (s *Drop_ddl_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_defaultContext

type Drop_defaultContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_defaultContext

func NewDrop_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_defaultContext

func NewEmptyDrop_defaultContext

func NewEmptyDrop_defaultContext() *Drop_defaultContext

func (*Drop_defaultContext) AllId

func (s *Drop_defaultContext) AllId() []IIdContext

func (*Drop_defaultContext) COMMA

func (*Drop_defaultContext) DEFAULT

func (s *Drop_defaultContext) DEFAULT() antlr.TerminalNode

func (*Drop_defaultContext) DOT

func (*Drop_defaultContext) DROP

func (*Drop_defaultContext) EXISTS

func (*Drop_defaultContext) EnterRule

func (s *Drop_defaultContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_defaultContext) ExitRule

func (s *Drop_defaultContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_defaultContext) GetDefault_name

func (s *Drop_defaultContext) GetDefault_name() IIdContext

func (*Drop_defaultContext) GetParser

func (s *Drop_defaultContext) GetParser() antlr.Parser

func (*Drop_defaultContext) GetRuleContext

func (s *Drop_defaultContext) GetRuleContext() antlr.RuleContext

func (*Drop_defaultContext) GetSchema_name

func (s *Drop_defaultContext) GetSchema_name() IIdContext

func (*Drop_defaultContext) IF

func (*Drop_defaultContext) Id

func (*Drop_defaultContext) IsDrop_defaultContext

func (*Drop_defaultContext) IsDrop_defaultContext()

func (*Drop_defaultContext) SetDefault_name

func (s *Drop_defaultContext) SetDefault_name(v IIdContext)

func (*Drop_defaultContext) SetSchema_name

func (s *Drop_defaultContext) SetSchema_name(v IIdContext)

func (*Drop_defaultContext) ToStringTree

func (s *Drop_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_dml_triggerContext

type Drop_dml_triggerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_dml_triggerContext

func NewDrop_dml_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_dml_triggerContext

func NewEmptyDrop_dml_triggerContext

func NewEmptyDrop_dml_triggerContext() *Drop_dml_triggerContext

func (*Drop_dml_triggerContext) AllCOMMA

func (s *Drop_dml_triggerContext) AllCOMMA() []antlr.TerminalNode

func (*Drop_dml_triggerContext) AllSimple_name

func (s *Drop_dml_triggerContext) AllSimple_name() []ISimple_nameContext

func (*Drop_dml_triggerContext) COMMA

func (*Drop_dml_triggerContext) DROP

func (*Drop_dml_triggerContext) EXISTS

func (*Drop_dml_triggerContext) EnterRule

func (s *Drop_dml_triggerContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_dml_triggerContext) ExitRule

func (s *Drop_dml_triggerContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_dml_triggerContext) GetParser

func (s *Drop_dml_triggerContext) GetParser() antlr.Parser

func (*Drop_dml_triggerContext) GetRuleContext

func (s *Drop_dml_triggerContext) GetRuleContext() antlr.RuleContext

func (*Drop_dml_triggerContext) IF

func (*Drop_dml_triggerContext) IsDrop_dml_triggerContext

func (*Drop_dml_triggerContext) IsDrop_dml_triggerContext()

func (*Drop_dml_triggerContext) SEMI

func (*Drop_dml_triggerContext) Simple_name

func (*Drop_dml_triggerContext) TRIGGER

func (*Drop_dml_triggerContext) ToStringTree

func (s *Drop_dml_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_endpointContext

type Drop_endpointContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_endpointContext

func NewDrop_endpointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_endpointContext

func NewEmptyDrop_endpointContext

func NewEmptyDrop_endpointContext() *Drop_endpointContext

func (*Drop_endpointContext) DROP

func (*Drop_endpointContext) ENDPOINT

func (s *Drop_endpointContext) ENDPOINT() antlr.TerminalNode

func (*Drop_endpointContext) EnterRule

func (s *Drop_endpointContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_endpointContext) ExitRule

func (s *Drop_endpointContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_endpointContext) GetEndPointName

func (s *Drop_endpointContext) GetEndPointName() IIdContext

func (*Drop_endpointContext) GetParser

func (s *Drop_endpointContext) GetParser() antlr.Parser

func (*Drop_endpointContext) GetRuleContext

func (s *Drop_endpointContext) GetRuleContext() antlr.RuleContext

func (*Drop_endpointContext) Id

func (*Drop_endpointContext) IsDrop_endpointContext

func (*Drop_endpointContext) IsDrop_endpointContext()

func (*Drop_endpointContext) SetEndPointName

func (s *Drop_endpointContext) SetEndPointName(v IIdContext)

func (*Drop_endpointContext) ToStringTree

func (s *Drop_endpointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_event_notificationsContext

type Drop_event_notificationsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_event_notificationsContext

func NewDrop_event_notificationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_event_notificationsContext

func NewEmptyDrop_event_notificationsContext

func NewEmptyDrop_event_notificationsContext() *Drop_event_notificationsContext

func (*Drop_event_notificationsContext) AllCOMMA

func (*Drop_event_notificationsContext) AllId

func (*Drop_event_notificationsContext) COMMA

func (*Drop_event_notificationsContext) DATABASE

func (*Drop_event_notificationsContext) DROP

func (*Drop_event_notificationsContext) EVENT

func (*Drop_event_notificationsContext) EnterRule

func (*Drop_event_notificationsContext) ExitRule

func (*Drop_event_notificationsContext) GetNotification_name

func (s *Drop_event_notificationsContext) GetNotification_name() IIdContext

func (*Drop_event_notificationsContext) GetParser

func (*Drop_event_notificationsContext) GetQueue_name

func (s *Drop_event_notificationsContext) GetQueue_name() IIdContext

func (*Drop_event_notificationsContext) GetRuleContext

func (*Drop_event_notificationsContext) Id

func (*Drop_event_notificationsContext) IsDrop_event_notificationsContext

func (*Drop_event_notificationsContext) IsDrop_event_notificationsContext()

func (*Drop_event_notificationsContext) NOTIFICATION

func (*Drop_event_notificationsContext) ON

func (*Drop_event_notificationsContext) QUEUE

func (*Drop_event_notificationsContext) SERVER

func (*Drop_event_notificationsContext) SetNotification_name

func (s *Drop_event_notificationsContext) SetNotification_name(v IIdContext)

func (*Drop_event_notificationsContext) SetQueue_name

func (s *Drop_event_notificationsContext) SetQueue_name(v IIdContext)

func (*Drop_event_notificationsContext) ToStringTree

func (s *Drop_event_notificationsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_event_sessionContext

type Drop_event_sessionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_event_sessionContext

func NewDrop_event_sessionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_event_sessionContext

func NewEmptyDrop_event_sessionContext

func NewEmptyDrop_event_sessionContext() *Drop_event_sessionContext

func (*Drop_event_sessionContext) DROP

func (*Drop_event_sessionContext) EVENT

func (*Drop_event_sessionContext) EnterRule

func (s *Drop_event_sessionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_event_sessionContext) ExitRule

func (s *Drop_event_sessionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_event_sessionContext) GetEvent_session_name

func (s *Drop_event_sessionContext) GetEvent_session_name() IIdContext

func (*Drop_event_sessionContext) GetParser

func (s *Drop_event_sessionContext) GetParser() antlr.Parser

func (*Drop_event_sessionContext) GetRuleContext

func (s *Drop_event_sessionContext) GetRuleContext() antlr.RuleContext

func (*Drop_event_sessionContext) Id

func (*Drop_event_sessionContext) IsDrop_event_sessionContext

func (*Drop_event_sessionContext) IsDrop_event_sessionContext()

func (*Drop_event_sessionContext) ON

func (*Drop_event_sessionContext) SERVER

func (*Drop_event_sessionContext) SESSION

func (*Drop_event_sessionContext) SetEvent_session_name

func (s *Drop_event_sessionContext) SetEvent_session_name(v IIdContext)

func (*Drop_event_sessionContext) ToStringTree

func (s *Drop_event_sessionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_external_data_sourceContext

type Drop_external_data_sourceContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_external_data_sourceContext

func NewDrop_external_data_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_data_sourceContext

func NewEmptyDrop_external_data_sourceContext

func NewEmptyDrop_external_data_sourceContext() *Drop_external_data_sourceContext

func (*Drop_external_data_sourceContext) DATA

func (*Drop_external_data_sourceContext) DROP

func (*Drop_external_data_sourceContext) EXTERNAL

func (*Drop_external_data_sourceContext) EnterRule

func (*Drop_external_data_sourceContext) ExitRule

func (*Drop_external_data_sourceContext) GetExternal_data_source_name

func (s *Drop_external_data_sourceContext) GetExternal_data_source_name() IIdContext

func (*Drop_external_data_sourceContext) GetParser

func (*Drop_external_data_sourceContext) GetRuleContext

func (*Drop_external_data_sourceContext) Id

func (*Drop_external_data_sourceContext) IsDrop_external_data_sourceContext

func (*Drop_external_data_sourceContext) IsDrop_external_data_sourceContext()

func (*Drop_external_data_sourceContext) SOURCE

func (*Drop_external_data_sourceContext) SetExternal_data_source_name

func (s *Drop_external_data_sourceContext) SetExternal_data_source_name(v IIdContext)

func (*Drop_external_data_sourceContext) ToStringTree

func (s *Drop_external_data_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_external_file_formatContext

type Drop_external_file_formatContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_external_file_formatContext

func NewDrop_external_file_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_file_formatContext

func NewEmptyDrop_external_file_formatContext

func NewEmptyDrop_external_file_formatContext() *Drop_external_file_formatContext

func (*Drop_external_file_formatContext) DROP

func (*Drop_external_file_formatContext) EXTERNAL

func (*Drop_external_file_formatContext) EnterRule

func (*Drop_external_file_formatContext) ExitRule

func (*Drop_external_file_formatContext) FILE

func (*Drop_external_file_formatContext) FORMAT

func (*Drop_external_file_formatContext) GetExternal_file_format_name

func (s *Drop_external_file_formatContext) GetExternal_file_format_name() IIdContext

func (*Drop_external_file_formatContext) GetParser

func (*Drop_external_file_formatContext) GetRuleContext

func (*Drop_external_file_formatContext) Id

func (*Drop_external_file_formatContext) IsDrop_external_file_formatContext

func (*Drop_external_file_formatContext) IsDrop_external_file_formatContext()

func (*Drop_external_file_formatContext) SetExternal_file_format_name

func (s *Drop_external_file_formatContext) SetExternal_file_format_name(v IIdContext)

func (*Drop_external_file_formatContext) ToStringTree

func (s *Drop_external_file_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_external_libraryContext

type Drop_external_libraryContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_external_libraryContext

func NewDrop_external_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_libraryContext

func NewEmptyDrop_external_libraryContext

func NewEmptyDrop_external_libraryContext() *Drop_external_libraryContext

func (*Drop_external_libraryContext) AUTHORIZATION

func (s *Drop_external_libraryContext) AUTHORIZATION() antlr.TerminalNode

func (*Drop_external_libraryContext) AllId

func (*Drop_external_libraryContext) DROP

func (*Drop_external_libraryContext) EXTERNAL

func (*Drop_external_libraryContext) EnterRule

func (s *Drop_external_libraryContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_external_libraryContext) ExitRule

func (*Drop_external_libraryContext) GetLibrary_name

func (s *Drop_external_libraryContext) GetLibrary_name() IIdContext

func (*Drop_external_libraryContext) GetOwner_name

func (s *Drop_external_libraryContext) GetOwner_name() IIdContext

func (*Drop_external_libraryContext) GetParser

func (s *Drop_external_libraryContext) GetParser() antlr.Parser

func (*Drop_external_libraryContext) GetRuleContext

func (s *Drop_external_libraryContext) GetRuleContext() antlr.RuleContext

func (*Drop_external_libraryContext) Id

func (*Drop_external_libraryContext) IsDrop_external_libraryContext

func (*Drop_external_libraryContext) IsDrop_external_libraryContext()

func (*Drop_external_libraryContext) LIBRARY

func (*Drop_external_libraryContext) SetLibrary_name

func (s *Drop_external_libraryContext) SetLibrary_name(v IIdContext)

func (*Drop_external_libraryContext) SetOwner_name

func (s *Drop_external_libraryContext) SetOwner_name(v IIdContext)

func (*Drop_external_libraryContext) ToStringTree

func (s *Drop_external_libraryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_external_resource_poolContext

type Drop_external_resource_poolContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_external_resource_poolContext

func NewDrop_external_resource_poolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_resource_poolContext

func NewEmptyDrop_external_resource_poolContext

func NewEmptyDrop_external_resource_poolContext() *Drop_external_resource_poolContext

func (*Drop_external_resource_poolContext) DROP

func (*Drop_external_resource_poolContext) EXTERNAL

func (*Drop_external_resource_poolContext) EnterRule

func (*Drop_external_resource_poolContext) ExitRule

func (*Drop_external_resource_poolContext) GetParser

func (*Drop_external_resource_poolContext) GetPool_name

func (*Drop_external_resource_poolContext) GetRuleContext

func (*Drop_external_resource_poolContext) Id

func (*Drop_external_resource_poolContext) IsDrop_external_resource_poolContext

func (*Drop_external_resource_poolContext) IsDrop_external_resource_poolContext()

func (*Drop_external_resource_poolContext) POOL

func (*Drop_external_resource_poolContext) RESOURCE

func (*Drop_external_resource_poolContext) SetPool_name

func (*Drop_external_resource_poolContext) ToStringTree

func (s *Drop_external_resource_poolContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_external_tableContext

type Drop_external_tableContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_external_tableContext

func NewDrop_external_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_tableContext

func NewEmptyDrop_external_tableContext

func NewEmptyDrop_external_tableContext() *Drop_external_tableContext

func (*Drop_external_tableContext) AllDOT

func (*Drop_external_tableContext) AllId

func (*Drop_external_tableContext) DOT

func (*Drop_external_tableContext) DROP

func (*Drop_external_tableContext) EXTERNAL

func (*Drop_external_tableContext) EnterRule

func (s *Drop_external_tableContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_external_tableContext) ExitRule

func (s *Drop_external_tableContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_external_tableContext) GetDatabase_name

func (s *Drop_external_tableContext) GetDatabase_name() IIdContext

func (*Drop_external_tableContext) GetParser

func (s *Drop_external_tableContext) GetParser() antlr.Parser

func (*Drop_external_tableContext) GetRuleContext

func (s *Drop_external_tableContext) GetRuleContext() antlr.RuleContext

func (*Drop_external_tableContext) GetSchema_name

func (s *Drop_external_tableContext) GetSchema_name() IIdContext

func (*Drop_external_tableContext) GetTable

func (s *Drop_external_tableContext) GetTable() IIdContext

func (*Drop_external_tableContext) Id

func (*Drop_external_tableContext) IsDrop_external_tableContext

func (*Drop_external_tableContext) IsDrop_external_tableContext()

func (*Drop_external_tableContext) SetDatabase_name

func (s *Drop_external_tableContext) SetDatabase_name(v IIdContext)

func (*Drop_external_tableContext) SetSchema_name

func (s *Drop_external_tableContext) SetSchema_name(v IIdContext)

func (*Drop_external_tableContext) SetTable

func (s *Drop_external_tableContext) SetTable(v IIdContext)

func (*Drop_external_tableContext) TABLE

func (*Drop_external_tableContext) ToStringTree

func (s *Drop_external_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_fulltext_catalogContext

type Drop_fulltext_catalogContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_fulltext_catalogContext

func NewDrop_fulltext_catalogContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_fulltext_catalogContext

func NewEmptyDrop_fulltext_catalogContext

func NewEmptyDrop_fulltext_catalogContext() *Drop_fulltext_catalogContext

func (*Drop_fulltext_catalogContext) CATALOG

func (*Drop_fulltext_catalogContext) DROP

func (*Drop_fulltext_catalogContext) EnterRule

func (s *Drop_fulltext_catalogContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_fulltext_catalogContext) ExitRule

func (*Drop_fulltext_catalogContext) FULLTEXT

func (*Drop_fulltext_catalogContext) GetCatalog_name

func (s *Drop_fulltext_catalogContext) GetCatalog_name() IIdContext

func (*Drop_fulltext_catalogContext) GetParser

func (s *Drop_fulltext_catalogContext) GetParser() antlr.Parser

func (*Drop_fulltext_catalogContext) GetRuleContext

func (s *Drop_fulltext_catalogContext) GetRuleContext() antlr.RuleContext

func (*Drop_fulltext_catalogContext) Id

func (*Drop_fulltext_catalogContext) IsDrop_fulltext_catalogContext

func (*Drop_fulltext_catalogContext) IsDrop_fulltext_catalogContext()

func (*Drop_fulltext_catalogContext) SetCatalog_name

func (s *Drop_fulltext_catalogContext) SetCatalog_name(v IIdContext)

func (*Drop_fulltext_catalogContext) ToStringTree

func (s *Drop_fulltext_catalogContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_fulltext_indexContext

type Drop_fulltext_indexContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_fulltext_indexContext

func NewDrop_fulltext_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_fulltext_indexContext

func NewEmptyDrop_fulltext_indexContext

func NewEmptyDrop_fulltext_indexContext() *Drop_fulltext_indexContext

func (*Drop_fulltext_indexContext) AllId

func (*Drop_fulltext_indexContext) DOT

func (*Drop_fulltext_indexContext) DROP

func (*Drop_fulltext_indexContext) EnterRule

func (s *Drop_fulltext_indexContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_fulltext_indexContext) ExitRule

func (s *Drop_fulltext_indexContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_fulltext_indexContext) FULLTEXT

func (*Drop_fulltext_indexContext) GetParser

func (s *Drop_fulltext_indexContext) GetParser() antlr.Parser

func (*Drop_fulltext_indexContext) GetRuleContext

func (s *Drop_fulltext_indexContext) GetRuleContext() antlr.RuleContext

func (*Drop_fulltext_indexContext) GetSchema

func (s *Drop_fulltext_indexContext) GetSchema() IIdContext

func (*Drop_fulltext_indexContext) GetTable

func (s *Drop_fulltext_indexContext) GetTable() IIdContext

func (*Drop_fulltext_indexContext) INDEX

func (*Drop_fulltext_indexContext) Id

func (*Drop_fulltext_indexContext) IsDrop_fulltext_indexContext

func (*Drop_fulltext_indexContext) IsDrop_fulltext_indexContext()

func (*Drop_fulltext_indexContext) ON

func (*Drop_fulltext_indexContext) SetSchema

func (s *Drop_fulltext_indexContext) SetSchema(v IIdContext)

func (*Drop_fulltext_indexContext) SetTable

func (s *Drop_fulltext_indexContext) SetTable(v IIdContext)

func (*Drop_fulltext_indexContext) ToStringTree

func (s *Drop_fulltext_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_fulltext_stoplistContext

type Drop_fulltext_stoplistContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_fulltext_stoplistContext

func NewDrop_fulltext_stoplistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_fulltext_stoplistContext

func NewEmptyDrop_fulltext_stoplistContext

func NewEmptyDrop_fulltext_stoplistContext() *Drop_fulltext_stoplistContext

func (*Drop_fulltext_stoplistContext) DROP

func (*Drop_fulltext_stoplistContext) EnterRule

func (s *Drop_fulltext_stoplistContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_fulltext_stoplistContext) ExitRule

func (*Drop_fulltext_stoplistContext) FULLTEXT

func (*Drop_fulltext_stoplistContext) GetParser

func (*Drop_fulltext_stoplistContext) GetRuleContext

func (s *Drop_fulltext_stoplistContext) GetRuleContext() antlr.RuleContext

func (*Drop_fulltext_stoplistContext) GetStoplist_name

func (s *Drop_fulltext_stoplistContext) GetStoplist_name() IIdContext

func (*Drop_fulltext_stoplistContext) Id

func (*Drop_fulltext_stoplistContext) IsDrop_fulltext_stoplistContext

func (*Drop_fulltext_stoplistContext) IsDrop_fulltext_stoplistContext()

func (*Drop_fulltext_stoplistContext) STOPLIST

func (*Drop_fulltext_stoplistContext) SetStoplist_name

func (s *Drop_fulltext_stoplistContext) SetStoplist_name(v IIdContext)

func (*Drop_fulltext_stoplistContext) ToStringTree

func (s *Drop_fulltext_stoplistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_functionContext

type Drop_functionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_functionContext

func NewDrop_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_functionContext

func NewEmptyDrop_functionContext

func NewEmptyDrop_functionContext() *Drop_functionContext

func (*Drop_functionContext) AllCOMMA

func (s *Drop_functionContext) AllCOMMA() []antlr.TerminalNode

func (*Drop_functionContext) AllFunc_proc_name_schema

func (s *Drop_functionContext) AllFunc_proc_name_schema() []IFunc_proc_name_schemaContext

func (*Drop_functionContext) COMMA

func (*Drop_functionContext) DROP

func (*Drop_functionContext) EXISTS

func (*Drop_functionContext) EnterRule

func (s *Drop_functionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_functionContext) ExitRule

func (s *Drop_functionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_functionContext) FUNCTION

func (s *Drop_functionContext) FUNCTION() antlr.TerminalNode

func (*Drop_functionContext) Func_proc_name_schema

func (s *Drop_functionContext) Func_proc_name_schema(i int) IFunc_proc_name_schemaContext

func (*Drop_functionContext) GetParser

func (s *Drop_functionContext) GetParser() antlr.Parser

func (*Drop_functionContext) GetRuleContext

func (s *Drop_functionContext) GetRuleContext() antlr.RuleContext

func (*Drop_functionContext) IF

func (*Drop_functionContext) IsDrop_functionContext

func (*Drop_functionContext) IsDrop_functionContext()

func (*Drop_functionContext) SEMI

func (*Drop_functionContext) ToStringTree

func (s *Drop_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_indexContext

type Drop_indexContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_indexContext

func NewDrop_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_indexContext

func NewEmptyDrop_indexContext

func NewEmptyDrop_indexContext() *Drop_indexContext

func (*Drop_indexContext) AllCOMMA

func (s *Drop_indexContext) AllCOMMA() []antlr.TerminalNode

func (*Drop_indexContext) AllDrop_backward_compatible_index

func (s *Drop_indexContext) AllDrop_backward_compatible_index() []IDrop_backward_compatible_indexContext

func (*Drop_indexContext) AllDrop_relational_or_xml_or_spatial_index

func (s *Drop_indexContext) AllDrop_relational_or_xml_or_spatial_index() []IDrop_relational_or_xml_or_spatial_indexContext

func (*Drop_indexContext) COMMA

func (*Drop_indexContext) DROP

func (*Drop_indexContext) Drop_backward_compatible_index

func (s *Drop_indexContext) Drop_backward_compatible_index(i int) IDrop_backward_compatible_indexContext

func (*Drop_indexContext) Drop_relational_or_xml_or_spatial_index

func (s *Drop_indexContext) Drop_relational_or_xml_or_spatial_index(i int) IDrop_relational_or_xml_or_spatial_indexContext

func (*Drop_indexContext) EXISTS

func (s *Drop_indexContext) EXISTS() antlr.TerminalNode

func (*Drop_indexContext) EnterRule

func (s *Drop_indexContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_indexContext) ExitRule

func (s *Drop_indexContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_indexContext) GetParser

func (s *Drop_indexContext) GetParser() antlr.Parser

func (*Drop_indexContext) GetRuleContext

func (s *Drop_indexContext) GetRuleContext() antlr.RuleContext

func (*Drop_indexContext) IF

func (*Drop_indexContext) INDEX

func (*Drop_indexContext) IsDrop_indexContext

func (*Drop_indexContext) IsDrop_indexContext()

func (*Drop_indexContext) SEMI

func (*Drop_indexContext) ToStringTree

func (s *Drop_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_loginContext

type Drop_loginContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_loginContext

func NewDrop_loginContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_loginContext

func NewEmptyDrop_loginContext

func NewEmptyDrop_loginContext() *Drop_loginContext

func (*Drop_loginContext) DROP

func (*Drop_loginContext) EnterRule

func (s *Drop_loginContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_loginContext) ExitRule

func (s *Drop_loginContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_loginContext) GetLogin_name

func (s *Drop_loginContext) GetLogin_name() IIdContext

func (*Drop_loginContext) GetParser

func (s *Drop_loginContext) GetParser() antlr.Parser

func (*Drop_loginContext) GetRuleContext

func (s *Drop_loginContext) GetRuleContext() antlr.RuleContext

func (*Drop_loginContext) Id

func (s *Drop_loginContext) Id() IIdContext

func (*Drop_loginContext) IsDrop_loginContext

func (*Drop_loginContext) IsDrop_loginContext()

func (*Drop_loginContext) LOGIN

func (*Drop_loginContext) SetLogin_name

func (s *Drop_loginContext) SetLogin_name(v IIdContext)

func (*Drop_loginContext) ToStringTree

func (s *Drop_loginContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_master_keyContext

type Drop_master_keyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_master_keyContext

func NewDrop_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_master_keyContext

func NewEmptyDrop_master_keyContext

func NewEmptyDrop_master_keyContext() *Drop_master_keyContext

func (*Drop_master_keyContext) DROP

func (*Drop_master_keyContext) EnterRule

func (s *Drop_master_keyContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_master_keyContext) ExitRule

func (s *Drop_master_keyContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_master_keyContext) GetParser

func (s *Drop_master_keyContext) GetParser() antlr.Parser

func (*Drop_master_keyContext) GetRuleContext

func (s *Drop_master_keyContext) GetRuleContext() antlr.RuleContext

func (*Drop_master_keyContext) IsDrop_master_keyContext

func (*Drop_master_keyContext) IsDrop_master_keyContext()

func (*Drop_master_keyContext) KEY

func (*Drop_master_keyContext) MASTER

func (*Drop_master_keyContext) ToStringTree

func (s *Drop_master_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_message_typeContext

type Drop_message_typeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_message_typeContext

func NewDrop_message_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_message_typeContext

func NewEmptyDrop_message_typeContext

func NewEmptyDrop_message_typeContext() *Drop_message_typeContext

func (*Drop_message_typeContext) DROP

func (*Drop_message_typeContext) EnterRule

func (s *Drop_message_typeContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_message_typeContext) ExitRule

func (s *Drop_message_typeContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_message_typeContext) GetMessage_type_name

func (s *Drop_message_typeContext) GetMessage_type_name() IIdContext

func (*Drop_message_typeContext) GetParser

func (s *Drop_message_typeContext) GetParser() antlr.Parser

func (*Drop_message_typeContext) GetRuleContext

func (s *Drop_message_typeContext) GetRuleContext() antlr.RuleContext

func (*Drop_message_typeContext) Id

func (*Drop_message_typeContext) IsDrop_message_typeContext

func (*Drop_message_typeContext) IsDrop_message_typeContext()

func (*Drop_message_typeContext) MESSAGE

func (*Drop_message_typeContext) SetMessage_type_name

func (s *Drop_message_typeContext) SetMessage_type_name(v IIdContext)

func (*Drop_message_typeContext) TYPE

func (*Drop_message_typeContext) ToStringTree

func (s *Drop_message_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_partition_functionContext

type Drop_partition_functionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_partition_functionContext

func NewDrop_partition_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_partition_functionContext

func NewEmptyDrop_partition_functionContext

func NewEmptyDrop_partition_functionContext() *Drop_partition_functionContext

func (*Drop_partition_functionContext) DROP

func (*Drop_partition_functionContext) EnterRule

func (*Drop_partition_functionContext) ExitRule

func (*Drop_partition_functionContext) FUNCTION

func (*Drop_partition_functionContext) GetParser

func (*Drop_partition_functionContext) GetPartition_function_name

func (s *Drop_partition_functionContext) GetPartition_function_name() IIdContext

func (*Drop_partition_functionContext) GetRuleContext

func (s *Drop_partition_functionContext) GetRuleContext() antlr.RuleContext

func (*Drop_partition_functionContext) Id

func (*Drop_partition_functionContext) IsDrop_partition_functionContext

func (*Drop_partition_functionContext) IsDrop_partition_functionContext()

func (*Drop_partition_functionContext) PARTITION

func (*Drop_partition_functionContext) SetPartition_function_name

func (s *Drop_partition_functionContext) SetPartition_function_name(v IIdContext)

func (*Drop_partition_functionContext) ToStringTree

func (s *Drop_partition_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_partition_schemeContext

type Drop_partition_schemeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_partition_schemeContext

func NewDrop_partition_schemeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_partition_schemeContext

func NewEmptyDrop_partition_schemeContext

func NewEmptyDrop_partition_schemeContext() *Drop_partition_schemeContext

func (*Drop_partition_schemeContext) DROP

func (*Drop_partition_schemeContext) EnterRule

func (s *Drop_partition_schemeContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_partition_schemeContext) ExitRule

func (*Drop_partition_schemeContext) GetParser

func (s *Drop_partition_schemeContext) GetParser() antlr.Parser

func (*Drop_partition_schemeContext) GetPartition_scheme_name

func (s *Drop_partition_schemeContext) GetPartition_scheme_name() IIdContext

func (*Drop_partition_schemeContext) GetRuleContext

func (s *Drop_partition_schemeContext) GetRuleContext() antlr.RuleContext

func (*Drop_partition_schemeContext) Id

func (*Drop_partition_schemeContext) IsDrop_partition_schemeContext

func (*Drop_partition_schemeContext) IsDrop_partition_schemeContext()

func (*Drop_partition_schemeContext) PARTITION

func (*Drop_partition_schemeContext) SCHEME

func (*Drop_partition_schemeContext) SetPartition_scheme_name

func (s *Drop_partition_schemeContext) SetPartition_scheme_name(v IIdContext)

func (*Drop_partition_schemeContext) ToStringTree

func (s *Drop_partition_schemeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_procedureContext

type Drop_procedureContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_procedureContext

func NewDrop_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_procedureContext

func NewEmptyDrop_procedureContext

func NewEmptyDrop_procedureContext() *Drop_procedureContext

func (*Drop_procedureContext) AllCOMMA

func (s *Drop_procedureContext) AllCOMMA() []antlr.TerminalNode

func (*Drop_procedureContext) AllFunc_proc_name_schema

func (s *Drop_procedureContext) AllFunc_proc_name_schema() []IFunc_proc_name_schemaContext

func (*Drop_procedureContext) COMMA

func (*Drop_procedureContext) DROP

func (*Drop_procedureContext) EXISTS

func (*Drop_procedureContext) EnterRule

func (s *Drop_procedureContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_procedureContext) ExitRule

func (s *Drop_procedureContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_procedureContext) Func_proc_name_schema

func (s *Drop_procedureContext) Func_proc_name_schema(i int) IFunc_proc_name_schemaContext

func (*Drop_procedureContext) GetParser

func (s *Drop_procedureContext) GetParser() antlr.Parser

func (*Drop_procedureContext) GetProc

func (s *Drop_procedureContext) GetProc() antlr.Token

func (*Drop_procedureContext) GetRuleContext

func (s *Drop_procedureContext) GetRuleContext() antlr.RuleContext

func (*Drop_procedureContext) IF

func (*Drop_procedureContext) IsDrop_procedureContext

func (*Drop_procedureContext) IsDrop_procedureContext()

func (*Drop_procedureContext) PROC

func (*Drop_procedureContext) PROCEDURE

func (s *Drop_procedureContext) PROCEDURE() antlr.TerminalNode

func (*Drop_procedureContext) SEMI

func (*Drop_procedureContext) SetProc

func (s *Drop_procedureContext) SetProc(v antlr.Token)

func (*Drop_procedureContext) ToStringTree

func (s *Drop_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_queueContext

type Drop_queueContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_queueContext

func NewDrop_queueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_queueContext

func NewEmptyDrop_queueContext

func NewEmptyDrop_queueContext() *Drop_queueContext

func (*Drop_queueContext) AllDOT

func (s *Drop_queueContext) AllDOT() []antlr.TerminalNode

func (*Drop_queueContext) AllId

func (s *Drop_queueContext) AllId() []IIdContext

func (*Drop_queueContext) DOT

func (*Drop_queueContext) DROP

func (*Drop_queueContext) EnterRule

func (s *Drop_queueContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_queueContext) ExitRule

func (s *Drop_queueContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_queueContext) GetDatabase_name

func (s *Drop_queueContext) GetDatabase_name() IIdContext

func (*Drop_queueContext) GetParser

func (s *Drop_queueContext) GetParser() antlr.Parser

func (*Drop_queueContext) GetQueue_name

func (s *Drop_queueContext) GetQueue_name() IIdContext

func (*Drop_queueContext) GetRuleContext

func (s *Drop_queueContext) GetRuleContext() antlr.RuleContext

func (*Drop_queueContext) GetSchema_name

func (s *Drop_queueContext) GetSchema_name() IIdContext

func (*Drop_queueContext) Id

func (s *Drop_queueContext) Id(i int) IIdContext

func (*Drop_queueContext) IsDrop_queueContext

func (*Drop_queueContext) IsDrop_queueContext()

func (*Drop_queueContext) QUEUE

func (*Drop_queueContext) SetDatabase_name

func (s *Drop_queueContext) SetDatabase_name(v IIdContext)

func (*Drop_queueContext) SetQueue_name

func (s *Drop_queueContext) SetQueue_name(v IIdContext)

func (*Drop_queueContext) SetSchema_name

func (s *Drop_queueContext) SetSchema_name(v IIdContext)

func (*Drop_queueContext) ToStringTree

func (s *Drop_queueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_relational_or_xml_or_spatial_indexContext

type Drop_relational_or_xml_or_spatial_indexContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_relational_or_xml_or_spatial_indexContext

func NewDrop_relational_or_xml_or_spatial_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_relational_or_xml_or_spatial_indexContext

func NewEmptyDrop_relational_or_xml_or_spatial_indexContext

func NewEmptyDrop_relational_or_xml_or_spatial_indexContext() *Drop_relational_or_xml_or_spatial_indexContext

func (*Drop_relational_or_xml_or_spatial_indexContext) EnterRule

func (*Drop_relational_or_xml_or_spatial_indexContext) ExitRule

func (*Drop_relational_or_xml_or_spatial_indexContext) Full_table_name

func (*Drop_relational_or_xml_or_spatial_indexContext) GetIndex_name

func (*Drop_relational_or_xml_or_spatial_indexContext) GetParser

func (*Drop_relational_or_xml_or_spatial_indexContext) GetRuleContext

func (*Drop_relational_or_xml_or_spatial_indexContext) Id

func (*Drop_relational_or_xml_or_spatial_indexContext) IsDrop_relational_or_xml_or_spatial_indexContext

func (*Drop_relational_or_xml_or_spatial_indexContext) IsDrop_relational_or_xml_or_spatial_indexContext()

func (*Drop_relational_or_xml_or_spatial_indexContext) ON

func (*Drop_relational_or_xml_or_spatial_indexContext) SetIndex_name

func (*Drop_relational_or_xml_or_spatial_indexContext) ToStringTree

func (s *Drop_relational_or_xml_or_spatial_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_remote_service_bindingContext

type Drop_remote_service_bindingContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_remote_service_bindingContext

func NewDrop_remote_service_bindingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_remote_service_bindingContext

func NewEmptyDrop_remote_service_bindingContext

func NewEmptyDrop_remote_service_bindingContext() *Drop_remote_service_bindingContext

func (*Drop_remote_service_bindingContext) BINDING

func (*Drop_remote_service_bindingContext) DROP

func (*Drop_remote_service_bindingContext) EnterRule

func (*Drop_remote_service_bindingContext) ExitRule

func (*Drop_remote_service_bindingContext) GetBinding_name

func (s *Drop_remote_service_bindingContext) GetBinding_name() IIdContext

func (*Drop_remote_service_bindingContext) GetParser

func (*Drop_remote_service_bindingContext) GetRuleContext

func (*Drop_remote_service_bindingContext) Id

func (*Drop_remote_service_bindingContext) IsDrop_remote_service_bindingContext

func (*Drop_remote_service_bindingContext) IsDrop_remote_service_bindingContext()

func (*Drop_remote_service_bindingContext) REMOTE

func (*Drop_remote_service_bindingContext) SERVICE

func (*Drop_remote_service_bindingContext) SetBinding_name

func (s *Drop_remote_service_bindingContext) SetBinding_name(v IIdContext)

func (*Drop_remote_service_bindingContext) ToStringTree

func (s *Drop_remote_service_bindingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_resource_poolContext

type Drop_resource_poolContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_resource_poolContext

func NewDrop_resource_poolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_resource_poolContext

func NewEmptyDrop_resource_poolContext

func NewEmptyDrop_resource_poolContext() *Drop_resource_poolContext

func (*Drop_resource_poolContext) DROP

func (*Drop_resource_poolContext) EnterRule

func (s *Drop_resource_poolContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_resource_poolContext) ExitRule

func (s *Drop_resource_poolContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_resource_poolContext) GetParser

func (s *Drop_resource_poolContext) GetParser() antlr.Parser

func (*Drop_resource_poolContext) GetPool_name

func (s *Drop_resource_poolContext) GetPool_name() IIdContext

func (*Drop_resource_poolContext) GetRuleContext

func (s *Drop_resource_poolContext) GetRuleContext() antlr.RuleContext

func (*Drop_resource_poolContext) Id

func (*Drop_resource_poolContext) IsDrop_resource_poolContext

func (*Drop_resource_poolContext) IsDrop_resource_poolContext()

func (*Drop_resource_poolContext) POOL

func (*Drop_resource_poolContext) RESOURCE

func (*Drop_resource_poolContext) SetPool_name

func (s *Drop_resource_poolContext) SetPool_name(v IIdContext)

func (*Drop_resource_poolContext) ToStringTree

func (s *Drop_resource_poolContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_routeContext

type Drop_routeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_routeContext

func NewDrop_routeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_routeContext

func NewEmptyDrop_routeContext

func NewEmptyDrop_routeContext() *Drop_routeContext

func (*Drop_routeContext) DROP

func (*Drop_routeContext) EnterRule

func (s *Drop_routeContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_routeContext) ExitRule

func (s *Drop_routeContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_routeContext) GetParser

func (s *Drop_routeContext) GetParser() antlr.Parser

func (*Drop_routeContext) GetRoute_name

func (s *Drop_routeContext) GetRoute_name() IIdContext

func (*Drop_routeContext) GetRuleContext

func (s *Drop_routeContext) GetRuleContext() antlr.RuleContext

func (*Drop_routeContext) Id

func (s *Drop_routeContext) Id() IIdContext

func (*Drop_routeContext) IsDrop_routeContext

func (*Drop_routeContext) IsDrop_routeContext()

func (*Drop_routeContext) ROUTE

func (*Drop_routeContext) SetRoute_name

func (s *Drop_routeContext) SetRoute_name(v IIdContext)

func (*Drop_routeContext) ToStringTree

func (s *Drop_routeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_ruleContext

type Drop_ruleContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_ruleContext

func NewDrop_ruleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_ruleContext

func NewEmptyDrop_ruleContext

func NewEmptyDrop_ruleContext() *Drop_ruleContext

func (*Drop_ruleContext) AllId

func (s *Drop_ruleContext) AllId() []IIdContext

func (*Drop_ruleContext) COMMA

func (s *Drop_ruleContext) COMMA() antlr.TerminalNode

func (*Drop_ruleContext) DOT

func (*Drop_ruleContext) DROP

func (*Drop_ruleContext) EXISTS

func (s *Drop_ruleContext) EXISTS() antlr.TerminalNode

func (*Drop_ruleContext) EnterRule

func (s *Drop_ruleContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_ruleContext) ExitRule

func (s *Drop_ruleContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_ruleContext) GetParser

func (s *Drop_ruleContext) GetParser() antlr.Parser

func (*Drop_ruleContext) GetRuleContext

func (s *Drop_ruleContext) GetRuleContext() antlr.RuleContext

func (*Drop_ruleContext) GetRule_name

func (s *Drop_ruleContext) GetRule_name() IIdContext

func (*Drop_ruleContext) GetSchema_name

func (s *Drop_ruleContext) GetSchema_name() IIdContext

func (*Drop_ruleContext) IF

func (*Drop_ruleContext) Id

func (s *Drop_ruleContext) Id(i int) IIdContext

func (*Drop_ruleContext) IsDrop_ruleContext

func (*Drop_ruleContext) IsDrop_ruleContext()

func (*Drop_ruleContext) RULE

func (*Drop_ruleContext) SetRule_name

func (s *Drop_ruleContext) SetRule_name(v IIdContext)

func (*Drop_ruleContext) SetSchema_name

func (s *Drop_ruleContext) SetSchema_name(v IIdContext)

func (*Drop_ruleContext) ToStringTree

func (s *Drop_ruleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_schemaContext

type Drop_schemaContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_schemaContext

func NewDrop_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_schemaContext

func NewEmptyDrop_schemaContext

func NewEmptyDrop_schemaContext() *Drop_schemaContext

func (*Drop_schemaContext) DROP

func (*Drop_schemaContext) EXISTS

func (*Drop_schemaContext) EnterRule

func (s *Drop_schemaContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_schemaContext) ExitRule

func (s *Drop_schemaContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_schemaContext) GetParser

func (s *Drop_schemaContext) GetParser() antlr.Parser

func (*Drop_schemaContext) GetRuleContext

func (s *Drop_schemaContext) GetRuleContext() antlr.RuleContext

func (*Drop_schemaContext) GetSchema_name

func (s *Drop_schemaContext) GetSchema_name() IIdContext

func (*Drop_schemaContext) IF

func (*Drop_schemaContext) Id

func (*Drop_schemaContext) IsDrop_schemaContext

func (*Drop_schemaContext) IsDrop_schemaContext()

func (*Drop_schemaContext) SCHEMA

func (*Drop_schemaContext) SetSchema_name

func (s *Drop_schemaContext) SetSchema_name(v IIdContext)

func (*Drop_schemaContext) ToStringTree

func (s *Drop_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_search_property_listContext

type Drop_search_property_listContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_search_property_listContext

func NewDrop_search_property_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_search_property_listContext

func NewEmptyDrop_search_property_listContext

func NewEmptyDrop_search_property_listContext() *Drop_search_property_listContext

func (*Drop_search_property_listContext) DROP

func (*Drop_search_property_listContext) EnterRule

func (*Drop_search_property_listContext) ExitRule

func (*Drop_search_property_listContext) GetParser

func (*Drop_search_property_listContext) GetProperty_list_name

func (s *Drop_search_property_listContext) GetProperty_list_name() IIdContext

func (*Drop_search_property_listContext) GetRuleContext

func (*Drop_search_property_listContext) Id

func (*Drop_search_property_listContext) IsDrop_search_property_listContext

func (*Drop_search_property_listContext) IsDrop_search_property_listContext()

func (*Drop_search_property_listContext) LIST

func (*Drop_search_property_listContext) PROPERTY

func (*Drop_search_property_listContext) SEARCH

func (*Drop_search_property_listContext) SetProperty_list_name

func (s *Drop_search_property_listContext) SetProperty_list_name(v IIdContext)

func (*Drop_search_property_listContext) ToStringTree

func (s *Drop_search_property_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_security_policyContext

type Drop_security_policyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_security_policyContext

func NewDrop_security_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_security_policyContext

func NewEmptyDrop_security_policyContext

func NewEmptyDrop_security_policyContext() *Drop_security_policyContext

func (*Drop_security_policyContext) AllId

func (*Drop_security_policyContext) DOT

func (*Drop_security_policyContext) DROP

func (*Drop_security_policyContext) EXISTS

func (*Drop_security_policyContext) EnterRule

func (s *Drop_security_policyContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_security_policyContext) ExitRule

func (s *Drop_security_policyContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_security_policyContext) GetParser

func (s *Drop_security_policyContext) GetParser() antlr.Parser

func (*Drop_security_policyContext) GetRuleContext

func (s *Drop_security_policyContext) GetRuleContext() antlr.RuleContext

func (*Drop_security_policyContext) GetSchema_name

func (s *Drop_security_policyContext) GetSchema_name() IIdContext

func (*Drop_security_policyContext) GetSecurity_policy_name

func (s *Drop_security_policyContext) GetSecurity_policy_name() IIdContext

func (*Drop_security_policyContext) IF

func (*Drop_security_policyContext) Id

func (*Drop_security_policyContext) IsDrop_security_policyContext

func (*Drop_security_policyContext) IsDrop_security_policyContext()

func (*Drop_security_policyContext) POLICY

func (*Drop_security_policyContext) SECURITY

func (*Drop_security_policyContext) SetSchema_name

func (s *Drop_security_policyContext) SetSchema_name(v IIdContext)

func (*Drop_security_policyContext) SetSecurity_policy_name

func (s *Drop_security_policyContext) SetSecurity_policy_name(v IIdContext)

func (*Drop_security_policyContext) ToStringTree

func (s *Drop_security_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_sequenceContext

type Drop_sequenceContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_sequenceContext

func NewDrop_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_sequenceContext

func NewEmptyDrop_sequenceContext

func NewEmptyDrop_sequenceContext() *Drop_sequenceContext

func (*Drop_sequenceContext) AllDOT

func (s *Drop_sequenceContext) AllDOT() []antlr.TerminalNode

func (*Drop_sequenceContext) AllId

func (s *Drop_sequenceContext) AllId() []IIdContext

func (*Drop_sequenceContext) COMMA

func (*Drop_sequenceContext) DOT

func (*Drop_sequenceContext) DROP

func (*Drop_sequenceContext) EXISTS

func (*Drop_sequenceContext) EnterRule

func (s *Drop_sequenceContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_sequenceContext) ExitRule

func (s *Drop_sequenceContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_sequenceContext) GetDatabase_name

func (s *Drop_sequenceContext) GetDatabase_name() IIdContext

func (*Drop_sequenceContext) GetParser

func (s *Drop_sequenceContext) GetParser() antlr.Parser

func (*Drop_sequenceContext) GetRuleContext

func (s *Drop_sequenceContext) GetRuleContext() antlr.RuleContext

func (*Drop_sequenceContext) GetSchema_name

func (s *Drop_sequenceContext) GetSchema_name() IIdContext

func (*Drop_sequenceContext) GetSequence_name

func (s *Drop_sequenceContext) GetSequence_name() IIdContext

func (*Drop_sequenceContext) IF

func (*Drop_sequenceContext) Id

func (*Drop_sequenceContext) IsDrop_sequenceContext

func (*Drop_sequenceContext) IsDrop_sequenceContext()

func (*Drop_sequenceContext) SEQUENCE

func (s *Drop_sequenceContext) SEQUENCE() antlr.TerminalNode

func (*Drop_sequenceContext) SetDatabase_name

func (s *Drop_sequenceContext) SetDatabase_name(v IIdContext)

func (*Drop_sequenceContext) SetSchema_name

func (s *Drop_sequenceContext) SetSchema_name(v IIdContext)

func (*Drop_sequenceContext) SetSequence_name

func (s *Drop_sequenceContext) SetSequence_name(v IIdContext)

func (*Drop_sequenceContext) ToStringTree

func (s *Drop_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_server_auditContext

type Drop_server_auditContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_server_auditContext

func NewDrop_server_auditContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_server_auditContext

func NewEmptyDrop_server_auditContext

func NewEmptyDrop_server_auditContext() *Drop_server_auditContext

func (*Drop_server_auditContext) AUDIT

func (*Drop_server_auditContext) DROP

func (*Drop_server_auditContext) EnterRule

func (s *Drop_server_auditContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_server_auditContext) ExitRule

func (s *Drop_server_auditContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_server_auditContext) GetAudit_name

func (s *Drop_server_auditContext) GetAudit_name() IIdContext

func (*Drop_server_auditContext) GetParser

func (s *Drop_server_auditContext) GetParser() antlr.Parser

func (*Drop_server_auditContext) GetRuleContext

func (s *Drop_server_auditContext) GetRuleContext() antlr.RuleContext

func (*Drop_server_auditContext) Id

func (*Drop_server_auditContext) IsDrop_server_auditContext

func (*Drop_server_auditContext) IsDrop_server_auditContext()

func (*Drop_server_auditContext) SERVER

func (*Drop_server_auditContext) SetAudit_name

func (s *Drop_server_auditContext) SetAudit_name(v IIdContext)

func (*Drop_server_auditContext) ToStringTree

func (s *Drop_server_auditContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_server_audit_specificationContext

type Drop_server_audit_specificationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_server_audit_specificationContext

func NewDrop_server_audit_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_server_audit_specificationContext

func NewEmptyDrop_server_audit_specificationContext

func NewEmptyDrop_server_audit_specificationContext() *Drop_server_audit_specificationContext

func (*Drop_server_audit_specificationContext) AUDIT

func (*Drop_server_audit_specificationContext) DROP

func (*Drop_server_audit_specificationContext) EnterRule

func (*Drop_server_audit_specificationContext) ExitRule

func (*Drop_server_audit_specificationContext) GetAudit_specification_name

func (s *Drop_server_audit_specificationContext) GetAudit_specification_name() IIdContext

func (*Drop_server_audit_specificationContext) GetParser

func (*Drop_server_audit_specificationContext) GetRuleContext

func (*Drop_server_audit_specificationContext) Id

func (*Drop_server_audit_specificationContext) IsDrop_server_audit_specificationContext

func (*Drop_server_audit_specificationContext) IsDrop_server_audit_specificationContext()

func (*Drop_server_audit_specificationContext) SERVER

func (*Drop_server_audit_specificationContext) SPECIFICATION

func (*Drop_server_audit_specificationContext) SetAudit_specification_name

func (s *Drop_server_audit_specificationContext) SetAudit_specification_name(v IIdContext)

func (*Drop_server_audit_specificationContext) ToStringTree

func (s *Drop_server_audit_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_server_roleContext

type Drop_server_roleContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_server_roleContext

func NewDrop_server_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_server_roleContext

func NewEmptyDrop_server_roleContext

func NewEmptyDrop_server_roleContext() *Drop_server_roleContext

func (*Drop_server_roleContext) DROP

func (*Drop_server_roleContext) EnterRule

func (s *Drop_server_roleContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_server_roleContext) ExitRule

func (s *Drop_server_roleContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_server_roleContext) GetParser

func (s *Drop_server_roleContext) GetParser() antlr.Parser

func (*Drop_server_roleContext) GetRole_name

func (s *Drop_server_roleContext) GetRole_name() IIdContext

func (*Drop_server_roleContext) GetRuleContext

func (s *Drop_server_roleContext) GetRuleContext() antlr.RuleContext

func (*Drop_server_roleContext) Id

func (*Drop_server_roleContext) IsDrop_server_roleContext

func (*Drop_server_roleContext) IsDrop_server_roleContext()

func (*Drop_server_roleContext) ROLE

func (*Drop_server_roleContext) SERVER

func (*Drop_server_roleContext) SetRole_name

func (s *Drop_server_roleContext) SetRole_name(v IIdContext)

func (*Drop_server_roleContext) ToStringTree

func (s *Drop_server_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_serviceContext

type Drop_serviceContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_serviceContext

func NewDrop_serviceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_serviceContext

func NewEmptyDrop_serviceContext

func NewEmptyDrop_serviceContext() *Drop_serviceContext

func (*Drop_serviceContext) DROP

func (*Drop_serviceContext) EnterRule

func (s *Drop_serviceContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_serviceContext) ExitRule

func (s *Drop_serviceContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_serviceContext) GetDropped_service_name

func (s *Drop_serviceContext) GetDropped_service_name() IIdContext

func (*Drop_serviceContext) GetParser

func (s *Drop_serviceContext) GetParser() antlr.Parser

func (*Drop_serviceContext) GetRuleContext

func (s *Drop_serviceContext) GetRuleContext() antlr.RuleContext

func (*Drop_serviceContext) Id

func (*Drop_serviceContext) IsDrop_serviceContext

func (*Drop_serviceContext) IsDrop_serviceContext()

func (*Drop_serviceContext) SERVICE

func (s *Drop_serviceContext) SERVICE() antlr.TerminalNode

func (*Drop_serviceContext) SetDropped_service_name

func (s *Drop_serviceContext) SetDropped_service_name(v IIdContext)

func (*Drop_serviceContext) ToStringTree

func (s *Drop_serviceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_signatureContext

type Drop_signatureContext struct {
	*antlr.BaseParserRuleContext

	Asym_key_name IIdContext
	// contains filtered or unexported fields
}

func NewDrop_signatureContext

func NewDrop_signatureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_signatureContext

func NewEmptyDrop_signatureContext

func NewEmptyDrop_signatureContext() *Drop_signatureContext

func (*Drop_signatureContext) ASYMMETRIC

func (s *Drop_signatureContext) ASYMMETRIC(i int) antlr.TerminalNode

func (*Drop_signatureContext) AllASYMMETRIC

func (s *Drop_signatureContext) AllASYMMETRIC() []antlr.TerminalNode

func (*Drop_signatureContext) AllCERTIFICATE

func (s *Drop_signatureContext) AllCERTIFICATE() []antlr.TerminalNode

func (*Drop_signatureContext) AllCOMMA

func (s *Drop_signatureContext) AllCOMMA() []antlr.TerminalNode

func (*Drop_signatureContext) AllId

func (s *Drop_signatureContext) AllId() []IIdContext

func (*Drop_signatureContext) AllKEY

func (*Drop_signatureContext) BY

func (*Drop_signatureContext) CERTIFICATE

func (s *Drop_signatureContext) CERTIFICATE(i int) antlr.TerminalNode

func (*Drop_signatureContext) COMMA

func (*Drop_signatureContext) COUNTER

func (*Drop_signatureContext) DOT

func (*Drop_signatureContext) DROP

func (*Drop_signatureContext) EnterRule

func (s *Drop_signatureContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_signatureContext) ExitRule

func (s *Drop_signatureContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_signatureContext) FROM

func (*Drop_signatureContext) GetAsym_key_name

func (s *Drop_signatureContext) GetAsym_key_name() IIdContext

func (*Drop_signatureContext) GetCert_name

func (s *Drop_signatureContext) GetCert_name() IIdContext

func (*Drop_signatureContext) GetModule_name

func (s *Drop_signatureContext) GetModule_name() IIdContext

func (*Drop_signatureContext) GetParser

func (s *Drop_signatureContext) GetParser() antlr.Parser

func (*Drop_signatureContext) GetRuleContext

func (s *Drop_signatureContext) GetRuleContext() antlr.RuleContext

func (*Drop_signatureContext) GetSchema_name

func (s *Drop_signatureContext) GetSchema_name() IIdContext

func (*Drop_signatureContext) Id

func (*Drop_signatureContext) IsDrop_signatureContext

func (*Drop_signatureContext) IsDrop_signatureContext()

func (*Drop_signatureContext) KEY

func (*Drop_signatureContext) SIGNATURE

func (s *Drop_signatureContext) SIGNATURE() antlr.TerminalNode

func (*Drop_signatureContext) SetAsym_key_name

func (s *Drop_signatureContext) SetAsym_key_name(v IIdContext)

func (*Drop_signatureContext) SetCert_name

func (s *Drop_signatureContext) SetCert_name(v IIdContext)

func (*Drop_signatureContext) SetModule_name

func (s *Drop_signatureContext) SetModule_name(v IIdContext)

func (*Drop_signatureContext) SetSchema_name

func (s *Drop_signatureContext) SetSchema_name(v IIdContext)

func (*Drop_signatureContext) ToStringTree

func (s *Drop_signatureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_statisticsContext

type Drop_statisticsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_statisticsContext

func NewDrop_statisticsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_statisticsContext

func NewEmptyDrop_statisticsContext

func NewEmptyDrop_statisticsContext() *Drop_statisticsContext

func (*Drop_statisticsContext) AllCOMMA

func (s *Drop_statisticsContext) AllCOMMA() []antlr.TerminalNode

func (*Drop_statisticsContext) AllDOT

func (*Drop_statisticsContext) AllId

func (s *Drop_statisticsContext) AllId() []IIdContext

func (*Drop_statisticsContext) AllTable_name

func (s *Drop_statisticsContext) AllTable_name() []ITable_nameContext

func (*Drop_statisticsContext) COMMA

func (*Drop_statisticsContext) DOT

func (*Drop_statisticsContext) DROP

func (*Drop_statisticsContext) EnterRule

func (s *Drop_statisticsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_statisticsContext) ExitRule

func (s *Drop_statisticsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_statisticsContext) GetName

func (s *Drop_statisticsContext) GetName() IIdContext

func (*Drop_statisticsContext) GetParser

func (s *Drop_statisticsContext) GetParser() antlr.Parser

func (*Drop_statisticsContext) GetRuleContext

func (s *Drop_statisticsContext) GetRuleContext() antlr.RuleContext

func (*Drop_statisticsContext) Id

func (*Drop_statisticsContext) IsDrop_statisticsContext

func (*Drop_statisticsContext) IsDrop_statisticsContext()

func (*Drop_statisticsContext) SEMI

func (*Drop_statisticsContext) STATISTICS

func (s *Drop_statisticsContext) STATISTICS() antlr.TerminalNode

func (*Drop_statisticsContext) SetName

func (s *Drop_statisticsContext) SetName(v IIdContext)

func (*Drop_statisticsContext) Table_name

func (*Drop_statisticsContext) ToStringTree

func (s *Drop_statisticsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_statistics_name_azure_dw_and_pdwContext

type Drop_statistics_name_azure_dw_and_pdwContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_statistics_name_azure_dw_and_pdwContext

func NewDrop_statistics_name_azure_dw_and_pdwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_statistics_name_azure_dw_and_pdwContext

func NewEmptyDrop_statistics_name_azure_dw_and_pdwContext

func NewEmptyDrop_statistics_name_azure_dw_and_pdwContext() *Drop_statistics_name_azure_dw_and_pdwContext

func (*Drop_statistics_name_azure_dw_and_pdwContext) AllDOT

func (*Drop_statistics_name_azure_dw_and_pdwContext) AllId

func (*Drop_statistics_name_azure_dw_and_pdwContext) DOT

func (*Drop_statistics_name_azure_dw_and_pdwContext) DROP

func (*Drop_statistics_name_azure_dw_and_pdwContext) EnterRule

func (*Drop_statistics_name_azure_dw_and_pdwContext) ExitRule

func (*Drop_statistics_name_azure_dw_and_pdwContext) GetObject_name

func (*Drop_statistics_name_azure_dw_and_pdwContext) GetParser

func (*Drop_statistics_name_azure_dw_and_pdwContext) GetRuleContext

func (*Drop_statistics_name_azure_dw_and_pdwContext) GetSchema_name

func (*Drop_statistics_name_azure_dw_and_pdwContext) GetStatistics_name

func (*Drop_statistics_name_azure_dw_and_pdwContext) Id

func (*Drop_statistics_name_azure_dw_and_pdwContext) IsDrop_statistics_name_azure_dw_and_pdwContext

func (*Drop_statistics_name_azure_dw_and_pdwContext) IsDrop_statistics_name_azure_dw_and_pdwContext()

func (*Drop_statistics_name_azure_dw_and_pdwContext) STATISTICS

func (*Drop_statistics_name_azure_dw_and_pdwContext) SetObject_name

func (*Drop_statistics_name_azure_dw_and_pdwContext) SetSchema_name

func (*Drop_statistics_name_azure_dw_and_pdwContext) SetStatistics_name

func (*Drop_statistics_name_azure_dw_and_pdwContext) ToStringTree

func (s *Drop_statistics_name_azure_dw_and_pdwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_symmetric_keyContext

type Drop_symmetric_keyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_symmetric_keyContext

func NewDrop_symmetric_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_symmetric_keyContext

func NewEmptyDrop_symmetric_keyContext

func NewEmptyDrop_symmetric_keyContext() *Drop_symmetric_keyContext

func (*Drop_symmetric_keyContext) AllKEY

func (*Drop_symmetric_keyContext) DROP

func (*Drop_symmetric_keyContext) EnterRule

func (s *Drop_symmetric_keyContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_symmetric_keyContext) ExitRule

func (s *Drop_symmetric_keyContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_symmetric_keyContext) GetParser

func (s *Drop_symmetric_keyContext) GetParser() antlr.Parser

func (*Drop_symmetric_keyContext) GetRuleContext

func (s *Drop_symmetric_keyContext) GetRuleContext() antlr.RuleContext

func (*Drop_symmetric_keyContext) GetSymmetric_key_name

func (s *Drop_symmetric_keyContext) GetSymmetric_key_name() IIdContext

func (*Drop_symmetric_keyContext) Id

func (*Drop_symmetric_keyContext) IsDrop_symmetric_keyContext

func (*Drop_symmetric_keyContext) IsDrop_symmetric_keyContext()

func (*Drop_symmetric_keyContext) KEY

func (*Drop_symmetric_keyContext) PROVIDER

func (*Drop_symmetric_keyContext) REMOVE

func (*Drop_symmetric_keyContext) SYMMETRIC

func (*Drop_symmetric_keyContext) SetSymmetric_key_name

func (s *Drop_symmetric_keyContext) SetSymmetric_key_name(v IIdContext)

func (*Drop_symmetric_keyContext) ToStringTree

func (s *Drop_symmetric_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_synonymContext

type Drop_synonymContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_synonymContext

func NewDrop_synonymContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_synonymContext

func NewEmptyDrop_synonymContext

func NewEmptyDrop_synonymContext() *Drop_synonymContext

func (*Drop_synonymContext) AllId

func (s *Drop_synonymContext) AllId() []IIdContext

func (*Drop_synonymContext) DOT

func (*Drop_synonymContext) DROP

func (*Drop_synonymContext) EXISTS

func (*Drop_synonymContext) EnterRule

func (s *Drop_synonymContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_synonymContext) ExitRule

func (s *Drop_synonymContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_synonymContext) GetParser

func (s *Drop_synonymContext) GetParser() antlr.Parser

func (*Drop_synonymContext) GetRuleContext

func (s *Drop_synonymContext) GetRuleContext() antlr.RuleContext

func (*Drop_synonymContext) GetSchema

func (s *Drop_synonymContext) GetSchema() IIdContext

func (*Drop_synonymContext) GetSynonym_name

func (s *Drop_synonymContext) GetSynonym_name() IIdContext

func (*Drop_synonymContext) IF

func (*Drop_synonymContext) Id

func (*Drop_synonymContext) IsDrop_synonymContext

func (*Drop_synonymContext) IsDrop_synonymContext()

func (*Drop_synonymContext) SYNONYM

func (s *Drop_synonymContext) SYNONYM() antlr.TerminalNode

func (*Drop_synonymContext) SetSchema

func (s *Drop_synonymContext) SetSchema(v IIdContext)

func (*Drop_synonymContext) SetSynonym_name

func (s *Drop_synonymContext) SetSynonym_name(v IIdContext)

func (*Drop_synonymContext) ToStringTree

func (s *Drop_synonymContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_tableContext

type Drop_tableContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_tableContext

func NewDrop_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_tableContext

func NewEmptyDrop_tableContext

func NewEmptyDrop_tableContext() *Drop_tableContext

func (*Drop_tableContext) DROP

func (*Drop_tableContext) EXISTS

func (s *Drop_tableContext) EXISTS() antlr.TerminalNode

func (*Drop_tableContext) EnterRule

func (s *Drop_tableContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_tableContext) ExitRule

func (s *Drop_tableContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_tableContext) GetParser

func (s *Drop_tableContext) GetParser() antlr.Parser

func (*Drop_tableContext) GetRuleContext

func (s *Drop_tableContext) GetRuleContext() antlr.RuleContext

func (*Drop_tableContext) IF

func (*Drop_tableContext) IsDrop_tableContext

func (*Drop_tableContext) IsDrop_tableContext()

func (*Drop_tableContext) SEMI

func (*Drop_tableContext) TABLE

func (*Drop_tableContext) Table_name

func (s *Drop_tableContext) Table_name() ITable_nameContext

func (*Drop_tableContext) ToStringTree

func (s *Drop_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_triggerContext

type Drop_triggerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_triggerContext

func NewDrop_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_triggerContext

func NewEmptyDrop_triggerContext

func NewEmptyDrop_triggerContext() *Drop_triggerContext

func (*Drop_triggerContext) Drop_ddl_trigger

func (s *Drop_triggerContext) Drop_ddl_trigger() IDrop_ddl_triggerContext

func (*Drop_triggerContext) Drop_dml_trigger

func (s *Drop_triggerContext) Drop_dml_trigger() IDrop_dml_triggerContext

func (*Drop_triggerContext) EnterRule

func (s *Drop_triggerContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_triggerContext) ExitRule

func (s *Drop_triggerContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_triggerContext) GetParser

func (s *Drop_triggerContext) GetParser() antlr.Parser

func (*Drop_triggerContext) GetRuleContext

func (s *Drop_triggerContext) GetRuleContext() antlr.RuleContext

func (*Drop_triggerContext) IsDrop_triggerContext

func (*Drop_triggerContext) IsDrop_triggerContext()

func (*Drop_triggerContext) ToStringTree

func (s *Drop_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_typeContext

type Drop_typeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_typeContext

func NewDrop_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_typeContext

func NewEmptyDrop_typeContext

func NewEmptyDrop_typeContext() *Drop_typeContext

func (*Drop_typeContext) DROP

func (*Drop_typeContext) EXISTS

func (s *Drop_typeContext) EXISTS() antlr.TerminalNode

func (*Drop_typeContext) EnterRule

func (s *Drop_typeContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_typeContext) ExitRule

func (s *Drop_typeContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_typeContext) GetName

func (*Drop_typeContext) GetParser

func (s *Drop_typeContext) GetParser() antlr.Parser

func (*Drop_typeContext) GetRuleContext

func (s *Drop_typeContext) GetRuleContext() antlr.RuleContext

func (*Drop_typeContext) IF

func (*Drop_typeContext) IsDrop_typeContext

func (*Drop_typeContext) IsDrop_typeContext()

func (*Drop_typeContext) SetName

func (s *Drop_typeContext) SetName(v ISimple_nameContext)

func (*Drop_typeContext) Simple_name

func (s *Drop_typeContext) Simple_name() ISimple_nameContext

func (*Drop_typeContext) TYPE

func (*Drop_typeContext) ToStringTree

func (s *Drop_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Drop_userContext

type Drop_userContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_userContext

func NewDrop_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_userContext

func NewEmptyDrop_userContext

func NewEmptyDrop_userContext() *Drop_userContext

func (*Drop_userContext) DROP

func (*Drop_userContext) EXISTS

func (s *Drop_userContext) EXISTS() antlr.TerminalNode

func (*Drop_userContext) EnterRule

func (s *Drop_userContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_userContext) ExitRule

func (s *Drop_userContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_userContext) GetParser

func (s *Drop_userContext) GetParser() antlr.Parser

func (*Drop_userContext) GetRuleContext

func (s *Drop_userContext) GetRuleContext() antlr.RuleContext

func (*Drop_userContext) GetUser_name

func (s *Drop_userContext) GetUser_name() IIdContext

func (*Drop_userContext) IF

func (*Drop_userContext) Id

func (s *Drop_userContext) Id() IIdContext

func (*Drop_userContext) IsDrop_userContext

func (*Drop_userContext) IsDrop_userContext()

func (*Drop_userContext) SetUser_name

func (s *Drop_userContext) SetUser_name(v IIdContext)

func (*Drop_userContext) ToStringTree

func (s *Drop_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Drop_userContext) USER

type Drop_viewContext

type Drop_viewContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_viewContext

func NewDrop_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_viewContext

func NewEmptyDrop_viewContext

func NewEmptyDrop_viewContext() *Drop_viewContext

func (*Drop_viewContext) AllCOMMA

func (s *Drop_viewContext) AllCOMMA() []antlr.TerminalNode

func (*Drop_viewContext) AllSimple_name

func (s *Drop_viewContext) AllSimple_name() []ISimple_nameContext

func (*Drop_viewContext) COMMA

func (s *Drop_viewContext) COMMA(i int) antlr.TerminalNode

func (*Drop_viewContext) DROP

func (*Drop_viewContext) EXISTS

func (s *Drop_viewContext) EXISTS() antlr.TerminalNode

func (*Drop_viewContext) EnterRule

func (s *Drop_viewContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_viewContext) ExitRule

func (s *Drop_viewContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_viewContext) GetParser

func (s *Drop_viewContext) GetParser() antlr.Parser

func (*Drop_viewContext) GetRuleContext

func (s *Drop_viewContext) GetRuleContext() antlr.RuleContext

func (*Drop_viewContext) IF

func (*Drop_viewContext) IsDrop_viewContext

func (*Drop_viewContext) IsDrop_viewContext()

func (*Drop_viewContext) SEMI

func (*Drop_viewContext) Simple_name

func (s *Drop_viewContext) Simple_name(i int) ISimple_nameContext

func (*Drop_viewContext) ToStringTree

func (s *Drop_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Drop_viewContext) VIEW

type Drop_workload_groupContext

type Drop_workload_groupContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_workload_groupContext

func NewDrop_workload_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_workload_groupContext

func NewEmptyDrop_workload_groupContext

func NewEmptyDrop_workload_groupContext() *Drop_workload_groupContext

func (*Drop_workload_groupContext) DROP

func (*Drop_workload_groupContext) EnterRule

func (s *Drop_workload_groupContext) EnterRule(listener antlr.ParseTreeListener)

func (*Drop_workload_groupContext) ExitRule

func (s *Drop_workload_groupContext) ExitRule(listener antlr.ParseTreeListener)

func (*Drop_workload_groupContext) GROUP

func (*Drop_workload_groupContext) GetGroup_name

func (s *Drop_workload_groupContext) GetGroup_name() IIdContext

func (*Drop_workload_groupContext) GetParser

func (s *Drop_workload_groupContext) GetParser() antlr.Parser

func (*Drop_workload_groupContext) GetRuleContext

func (s *Drop_workload_groupContext) GetRuleContext() antlr.RuleContext

func (*Drop_workload_groupContext) Id

func (*Drop_workload_groupContext) IsDrop_workload_groupContext

func (*Drop_workload_groupContext) IsDrop_workload_groupContext()

func (*Drop_workload_groupContext) SetGroup_name

func (s *Drop_workload_groupContext) SetGroup_name(v IIdContext)

func (*Drop_workload_groupContext) ToStringTree

func (s *Drop_workload_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Drop_workload_groupContext) WORKLOAD

type Drop_xml_schema_collectionContext

type Drop_xml_schema_collectionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewDrop_xml_schema_collectionContext

func NewDrop_xml_schema_collectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_xml_schema_collectionContext

func NewEmptyDrop_xml_schema_collectionContext

func NewEmptyDrop_xml_schema_collectionContext() *Drop_xml_schema_collectionContext

func (*Drop_xml_schema_collectionContext) AllId

func (*Drop_xml_schema_collectionContext) COLLECTION

func (*Drop_xml_schema_collectionContext) DOT

func (*Drop_xml_schema_collectionContext) DROP

func (*Drop_xml_schema_collectionContext) EnterRule

func (*Drop_xml_schema_collectionContext) ExitRule

func (*Drop_xml_schema_collectionContext) GetParser

func (*Drop_xml_schema_collectionContext) GetRelational_schema

func (s *Drop_xml_schema_collectionContext) GetRelational_schema() IIdContext

func (*Drop_xml_schema_collectionContext) GetRuleContext

func (*Drop_xml_schema_collectionContext) GetSql_identifier

func (s *Drop_xml_schema_collectionContext) GetSql_identifier() IIdContext

func (*Drop_xml_schema_collectionContext) Id

func (*Drop_xml_schema_collectionContext) IsDrop_xml_schema_collectionContext

func (*Drop_xml_schema_collectionContext) IsDrop_xml_schema_collectionContext()

func (*Drop_xml_schema_collectionContext) SCHEMA

func (*Drop_xml_schema_collectionContext) SetRelational_schema

func (s *Drop_xml_schema_collectionContext) SetRelational_schema(v IIdContext)

func (*Drop_xml_schema_collectionContext) SetSql_identifier

func (s *Drop_xml_schema_collectionContext) SetSql_identifier(v IIdContext)

func (*Drop_xml_schema_collectionContext) ToStringTree

func (s *Drop_xml_schema_collectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Drop_xml_schema_collectionContext) XML

type Empty_statementContext

type Empty_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEmpty_statementContext

func NewEmptyEmpty_statementContext() *Empty_statementContext

func NewEmpty_statementContext

func NewEmpty_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Empty_statementContext

func (*Empty_statementContext) EnterRule

func (s *Empty_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Empty_statementContext) ExitRule

func (s *Empty_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Empty_statementContext) GetParser

func (s *Empty_statementContext) GetParser() antlr.Parser

func (*Empty_statementContext) GetRuleContext

func (s *Empty_statementContext) GetRuleContext() antlr.RuleContext

func (*Empty_statementContext) IsEmpty_statementContext

func (*Empty_statementContext) IsEmpty_statementContext()

func (*Empty_statementContext) SEMI

func (*Empty_statementContext) ToStringTree

func (s *Empty_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Enable_triggerContext

type Enable_triggerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnable_triggerContext

func NewEmptyEnable_triggerContext() *Enable_triggerContext

func NewEnable_triggerContext

func NewEnable_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_triggerContext

func (*Enable_triggerContext) ALL

func (*Enable_triggerContext) AllALL

func (*Enable_triggerContext) AllCOMMA

func (s *Enable_triggerContext) AllCOMMA() []antlr.TerminalNode

func (*Enable_triggerContext) AllDOT

func (*Enable_triggerContext) AllId

func (s *Enable_triggerContext) AllId() []IIdContext

func (*Enable_triggerContext) COMMA

func (*Enable_triggerContext) DATABASE

func (*Enable_triggerContext) DOT

func (*Enable_triggerContext) ENABLE

func (*Enable_triggerContext) EnterRule

func (s *Enable_triggerContext) EnterRule(listener antlr.ParseTreeListener)

func (*Enable_triggerContext) ExitRule

func (s *Enable_triggerContext) ExitRule(listener antlr.ParseTreeListener)

func (*Enable_triggerContext) GetObject_name

func (s *Enable_triggerContext) GetObject_name() IIdContext

func (*Enable_triggerContext) GetParser

func (s *Enable_triggerContext) GetParser() antlr.Parser

func (*Enable_triggerContext) GetRuleContext

func (s *Enable_triggerContext) GetRuleContext() antlr.RuleContext

func (*Enable_triggerContext) GetSchema_id

func (s *Enable_triggerContext) GetSchema_id() IIdContext

func (*Enable_triggerContext) GetSchema_name

func (s *Enable_triggerContext) GetSchema_name() IIdContext

func (*Enable_triggerContext) GetTrigger_name

func (s *Enable_triggerContext) GetTrigger_name() IIdContext

func (*Enable_triggerContext) Id

func (*Enable_triggerContext) IsEnable_triggerContext

func (*Enable_triggerContext) IsEnable_triggerContext()

func (*Enable_triggerContext) ON

func (*Enable_triggerContext) SERVER

func (*Enable_triggerContext) SetObject_name

func (s *Enable_triggerContext) SetObject_name(v IIdContext)

func (*Enable_triggerContext) SetSchema_id

func (s *Enable_triggerContext) SetSchema_id(v IIdContext)

func (*Enable_triggerContext) SetSchema_name

func (s *Enable_triggerContext) SetSchema_name(v IIdContext)

func (*Enable_triggerContext) SetTrigger_name

func (s *Enable_triggerContext) SetTrigger_name(v IIdContext)

func (*Enable_triggerContext) TRIGGER

func (*Enable_triggerContext) ToStringTree

func (s *Enable_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Encryption_mechanismContext

type Encryption_mechanismContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEncryption_mechanismContext

func NewEmptyEncryption_mechanismContext() *Encryption_mechanismContext

func NewEncryption_mechanismContext

func NewEncryption_mechanismContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Encryption_mechanismContext

func (*Encryption_mechanismContext) ASYMMETRIC

func (*Encryption_mechanismContext) CERTIFICATE

func (*Encryption_mechanismContext) EQUAL

func (*Encryption_mechanismContext) EnterRule

func (s *Encryption_mechanismContext) EnterRule(listener antlr.ParseTreeListener)

func (*Encryption_mechanismContext) ExitRule

func (s *Encryption_mechanismContext) ExitRule(listener antlr.ParseTreeListener)

func (*Encryption_mechanismContext) GetAsym_key_name

func (s *Encryption_mechanismContext) GetAsym_key_name() IIdContext

func (*Encryption_mechanismContext) GetCertificate_name

func (s *Encryption_mechanismContext) GetCertificate_name() IIdContext

func (*Encryption_mechanismContext) GetDecrypting_Key_name

func (s *Encryption_mechanismContext) GetDecrypting_Key_name() IIdContext

func (*Encryption_mechanismContext) GetParser

func (s *Encryption_mechanismContext) GetParser() antlr.Parser

func (*Encryption_mechanismContext) GetRuleContext

func (s *Encryption_mechanismContext) GetRuleContext() antlr.RuleContext

func (*Encryption_mechanismContext) Id

func (*Encryption_mechanismContext) IsEncryption_mechanismContext

func (*Encryption_mechanismContext) IsEncryption_mechanismContext()

func (*Encryption_mechanismContext) KEY

func (*Encryption_mechanismContext) PASSWORD

func (*Encryption_mechanismContext) STRING

func (*Encryption_mechanismContext) SYMMETRIC

func (*Encryption_mechanismContext) SetAsym_key_name

func (s *Encryption_mechanismContext) SetAsym_key_name(v IIdContext)

func (*Encryption_mechanismContext) SetCertificate_name

func (s *Encryption_mechanismContext) SetCertificate_name(v IIdContext)

func (*Encryption_mechanismContext) SetDecrypting_Key_name

func (s *Encryption_mechanismContext) SetDecrypting_Key_name(v IIdContext)

func (*Encryption_mechanismContext) ToStringTree

func (s *Encryption_mechanismContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type End_conversationContext

type End_conversationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEnd_conversationContext

func NewEmptyEnd_conversationContext() *End_conversationContext

func NewEnd_conversationContext

func NewEnd_conversationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *End_conversationContext

func (*End_conversationContext) AllEQUAL

func (s *End_conversationContext) AllEQUAL() []antlr.TerminalNode

func (*End_conversationContext) AllLOCAL_ID

func (s *End_conversationContext) AllLOCAL_ID() []antlr.TerminalNode

func (*End_conversationContext) AllSTRING

func (s *End_conversationContext) AllSTRING() []antlr.TerminalNode

func (*End_conversationContext) CLEANUP

func (*End_conversationContext) CONVERSATION

func (s *End_conversationContext) CONVERSATION() antlr.TerminalNode

func (*End_conversationContext) DESCRIPTION

func (s *End_conversationContext) DESCRIPTION() antlr.TerminalNode

func (*End_conversationContext) END

func (*End_conversationContext) EQUAL

func (*End_conversationContext) ERROR

func (*End_conversationContext) EnterRule

func (s *End_conversationContext) EnterRule(listener antlr.ParseTreeListener)

func (*End_conversationContext) ExitRule

func (s *End_conversationContext) ExitRule(listener antlr.ParseTreeListener)

func (*End_conversationContext) GetConversation_handle

func (s *End_conversationContext) GetConversation_handle() antlr.Token

func (*End_conversationContext) GetFailure_text

func (s *End_conversationContext) GetFailure_text() antlr.Token

func (*End_conversationContext) GetFaliure_code

func (s *End_conversationContext) GetFaliure_code() antlr.Token

func (*End_conversationContext) GetParser

func (s *End_conversationContext) GetParser() antlr.Parser

func (*End_conversationContext) GetRuleContext

func (s *End_conversationContext) GetRuleContext() antlr.RuleContext

func (*End_conversationContext) IsEnd_conversationContext

func (*End_conversationContext) IsEnd_conversationContext()

func (*End_conversationContext) LOCAL_ID

func (*End_conversationContext) SEMI

func (*End_conversationContext) STRING

func (*End_conversationContext) SetConversation_handle

func (s *End_conversationContext) SetConversation_handle(v antlr.Token)

func (*End_conversationContext) SetFailure_text

func (s *End_conversationContext) SetFailure_text(v antlr.Token)

func (*End_conversationContext) SetFaliure_code

func (s *End_conversationContext) SetFaliure_code(v antlr.Token)

func (*End_conversationContext) ToStringTree

func (s *End_conversationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*End_conversationContext) WITH

type Entity_nameContext

type Entity_nameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEntity_nameContext

func NewEmptyEntity_nameContext() *Entity_nameContext

func NewEntity_nameContext

func NewEntity_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Entity_nameContext

func (*Entity_nameContext) AllDOT

func (s *Entity_nameContext) AllDOT() []antlr.TerminalNode

func (*Entity_nameContext) AllId

func (s *Entity_nameContext) AllId() []IIdContext

func (*Entity_nameContext) DOT

func (*Entity_nameContext) EnterRule

func (s *Entity_nameContext) EnterRule(listener antlr.ParseTreeListener)

func (*Entity_nameContext) ExitRule

func (s *Entity_nameContext) ExitRule(listener antlr.ParseTreeListener)

func (*Entity_nameContext) GetDatabase

func (s *Entity_nameContext) GetDatabase() IIdContext

func (*Entity_nameContext) GetParser

func (s *Entity_nameContext) GetParser() antlr.Parser

func (*Entity_nameContext) GetRuleContext

func (s *Entity_nameContext) GetRuleContext() antlr.RuleContext

func (*Entity_nameContext) GetSchema

func (s *Entity_nameContext) GetSchema() IIdContext

func (*Entity_nameContext) GetServer

func (s *Entity_nameContext) GetServer() IIdContext

func (*Entity_nameContext) GetTable

func (s *Entity_nameContext) GetTable() IIdContext

func (*Entity_nameContext) Id

func (*Entity_nameContext) IsEntity_nameContext

func (*Entity_nameContext) IsEntity_nameContext()

func (*Entity_nameContext) SetDatabase

func (s *Entity_nameContext) SetDatabase(v IIdContext)

func (*Entity_nameContext) SetSchema

func (s *Entity_nameContext) SetSchema(v IIdContext)

func (*Entity_nameContext) SetServer

func (s *Entity_nameContext) SetServer(v IIdContext)

func (*Entity_nameContext) SetTable

func (s *Entity_nameContext) SetTable(v IIdContext)

func (*Entity_nameContext) ToStringTree

func (s *Entity_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Entity_name_for_azure_dwContext

type Entity_name_for_azure_dwContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEntity_name_for_azure_dwContext

func NewEmptyEntity_name_for_azure_dwContext() *Entity_name_for_azure_dwContext

func NewEntity_name_for_azure_dwContext

func NewEntity_name_for_azure_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Entity_name_for_azure_dwContext

func (*Entity_name_for_azure_dwContext) AllId

func (*Entity_name_for_azure_dwContext) DOT

func (*Entity_name_for_azure_dwContext) EnterRule

func (*Entity_name_for_azure_dwContext) ExitRule

func (*Entity_name_for_azure_dwContext) GetObject_name

func (s *Entity_name_for_azure_dwContext) GetObject_name() IIdContext

func (*Entity_name_for_azure_dwContext) GetParser

func (*Entity_name_for_azure_dwContext) GetRuleContext

func (*Entity_name_for_azure_dwContext) GetSchema

func (*Entity_name_for_azure_dwContext) Id

func (*Entity_name_for_azure_dwContext) IsEntity_name_for_azure_dwContext

func (*Entity_name_for_azure_dwContext) IsEntity_name_for_azure_dwContext()

func (*Entity_name_for_azure_dwContext) SetObject_name

func (s *Entity_name_for_azure_dwContext) SetObject_name(v IIdContext)

func (*Entity_name_for_azure_dwContext) SetSchema

func (*Entity_name_for_azure_dwContext) ToStringTree

func (s *Entity_name_for_azure_dwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Entity_name_for_parallel_dwContext

type Entity_name_for_parallel_dwContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEntity_name_for_parallel_dwContext

func NewEmptyEntity_name_for_parallel_dwContext() *Entity_name_for_parallel_dwContext

func NewEntity_name_for_parallel_dwContext

func NewEntity_name_for_parallel_dwContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Entity_name_for_parallel_dwContext

func (*Entity_name_for_parallel_dwContext) AllId

func (*Entity_name_for_parallel_dwContext) DOT

func (*Entity_name_for_parallel_dwContext) EnterRule

func (*Entity_name_for_parallel_dwContext) ExitRule

func (*Entity_name_for_parallel_dwContext) GetObject_name

func (s *Entity_name_for_parallel_dwContext) GetObject_name() IIdContext

func (*Entity_name_for_parallel_dwContext) GetParser

func (*Entity_name_for_parallel_dwContext) GetRuleContext

func (*Entity_name_for_parallel_dwContext) GetSchema

func (*Entity_name_for_parallel_dwContext) GetSchema_database

func (s *Entity_name_for_parallel_dwContext) GetSchema_database() IIdContext

func (*Entity_name_for_parallel_dwContext) Id

func (*Entity_name_for_parallel_dwContext) IsEntity_name_for_parallel_dwContext

func (*Entity_name_for_parallel_dwContext) IsEntity_name_for_parallel_dwContext()

func (*Entity_name_for_parallel_dwContext) SetObject_name

func (s *Entity_name_for_parallel_dwContext) SetObject_name(v IIdContext)

func (*Entity_name_for_parallel_dwContext) SetSchema

func (*Entity_name_for_parallel_dwContext) SetSchema_database

func (s *Entity_name_for_parallel_dwContext) SetSchema_database(v IIdContext)

func (*Entity_name_for_parallel_dwContext) ToStringTree

func (s *Entity_name_for_parallel_dwContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Entity_toContext

type Entity_toContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEntity_toContext

func NewEmptyEntity_toContext() *Entity_toContext

func NewEntity_toContext

func NewEntity_toContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Entity_toContext

func (*Entity_toContext) EnterRule

func (s *Entity_toContext) EnterRule(listener antlr.ParseTreeListener)

func (*Entity_toContext) ExitRule

func (s *Entity_toContext) ExitRule(listener antlr.ParseTreeListener)

func (*Entity_toContext) GetParser

func (s *Entity_toContext) GetParser() antlr.Parser

func (*Entity_toContext) GetRuleContext

func (s *Entity_toContext) GetRuleContext() antlr.RuleContext

func (*Entity_toContext) IsEntity_toContext

func (*Entity_toContext) IsEntity_toContext()

func (*Entity_toContext) TO

func (*Entity_toContext) ToStringTree

func (s *Entity_toContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Event_session_predicate_expressionContext

type Event_session_predicate_expressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEvent_session_predicate_expressionContext

func NewEmptyEvent_session_predicate_expressionContext() *Event_session_predicate_expressionContext

func NewEvent_session_predicate_expressionContext

func NewEvent_session_predicate_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_session_predicate_expressionContext

func (*Event_session_predicate_expressionContext) AND

func (*Event_session_predicate_expressionContext) AllAND

func (*Event_session_predicate_expressionContext) AllCOMMA

func (*Event_session_predicate_expressionContext) AllEvent_session_predicate_expression

func (*Event_session_predicate_expressionContext) AllEvent_session_predicate_factor

func (*Event_session_predicate_expressionContext) AllLR_BRACKET

func (*Event_session_predicate_expressionContext) AllNOT

func (*Event_session_predicate_expressionContext) AllOR

func (*Event_session_predicate_expressionContext) AllRR_BRACKET

func (*Event_session_predicate_expressionContext) COMMA

func (*Event_session_predicate_expressionContext) EnterRule

func (*Event_session_predicate_expressionContext) Event_session_predicate_expression

func (*Event_session_predicate_expressionContext) Event_session_predicate_factor

func (*Event_session_predicate_expressionContext) ExitRule

func (*Event_session_predicate_expressionContext) GetParser

func (*Event_session_predicate_expressionContext) GetRuleContext

func (*Event_session_predicate_expressionContext) IsEvent_session_predicate_expressionContext

func (*Event_session_predicate_expressionContext) IsEvent_session_predicate_expressionContext()

func (*Event_session_predicate_expressionContext) LR_BRACKET

func (*Event_session_predicate_expressionContext) NOT

func (*Event_session_predicate_expressionContext) OR

func (*Event_session_predicate_expressionContext) RR_BRACKET

func (*Event_session_predicate_expressionContext) ToStringTree

func (s *Event_session_predicate_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Event_session_predicate_factorContext

type Event_session_predicate_factorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEvent_session_predicate_factorContext

func NewEmptyEvent_session_predicate_factorContext() *Event_session_predicate_factorContext

func NewEvent_session_predicate_factorContext

func NewEvent_session_predicate_factorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_session_predicate_factorContext

func (*Event_session_predicate_factorContext) EnterRule

func (*Event_session_predicate_factorContext) Event_session_predicate_expression

func (*Event_session_predicate_factorContext) Event_session_predicate_leaf

func (*Event_session_predicate_factorContext) ExitRule

func (*Event_session_predicate_factorContext) GetParser

func (*Event_session_predicate_factorContext) GetRuleContext

func (*Event_session_predicate_factorContext) IsEvent_session_predicate_factorContext

func (*Event_session_predicate_factorContext) IsEvent_session_predicate_factorContext()

func (*Event_session_predicate_factorContext) LR_BRACKET

func (*Event_session_predicate_factorContext) RR_BRACKET

func (*Event_session_predicate_factorContext) ToStringTree

func (s *Event_session_predicate_factorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Event_session_predicate_leafContext

type Event_session_predicate_leafContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEvent_session_predicate_leafContext

func NewEmptyEvent_session_predicate_leafContext() *Event_session_predicate_leafContext

func NewEvent_session_predicate_leafContext

func NewEvent_session_predicate_leafContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_session_predicate_leafContext

func (*Event_session_predicate_leafContext) AllDOT

func (*Event_session_predicate_leafContext) AllId

func (*Event_session_predicate_leafContext) COMMA

func (*Event_session_predicate_leafContext) DECIMAL

func (*Event_session_predicate_leafContext) DOT

func (*Event_session_predicate_leafContext) EQUAL

func (*Event_session_predicate_leafContext) EXCLAMATION

func (*Event_session_predicate_leafContext) EnterRule

func (*Event_session_predicate_leafContext) ExitRule

func (*Event_session_predicate_leafContext) GREATER

func (*Event_session_predicate_leafContext) GetEvent_field_name

func (s *Event_session_predicate_leafContext) GetEvent_field_name() IIdContext

func (*Event_session_predicate_leafContext) GetEvent_module_guid

func (s *Event_session_predicate_leafContext) GetEvent_module_guid() IIdContext

func (*Event_session_predicate_leafContext) GetEvent_package_name

func (s *Event_session_predicate_leafContext) GetEvent_package_name() IIdContext

func (*Event_session_predicate_leafContext) GetParser

func (*Event_session_predicate_leafContext) GetPredicate_compare_name

func (s *Event_session_predicate_leafContext) GetPredicate_compare_name() IIdContext

func (*Event_session_predicate_leafContext) GetPredicate_source_name

func (s *Event_session_predicate_leafContext) GetPredicate_source_name() IIdContext

func (*Event_session_predicate_leafContext) GetRuleContext

func (*Event_session_predicate_leafContext) Id

func (*Event_session_predicate_leafContext) IsEvent_session_predicate_leafContext

func (*Event_session_predicate_leafContext) IsEvent_session_predicate_leafContext()

func (*Event_session_predicate_leafContext) LESS

func (*Event_session_predicate_leafContext) LR_BRACKET

func (*Event_session_predicate_leafContext) RR_BRACKET

func (*Event_session_predicate_leafContext) STRING

func (*Event_session_predicate_leafContext) SetEvent_field_name

func (s *Event_session_predicate_leafContext) SetEvent_field_name(v IIdContext)

func (*Event_session_predicate_leafContext) SetEvent_module_guid

func (s *Event_session_predicate_leafContext) SetEvent_module_guid(v IIdContext)

func (*Event_session_predicate_leafContext) SetEvent_package_name

func (s *Event_session_predicate_leafContext) SetEvent_package_name(v IIdContext)

func (*Event_session_predicate_leafContext) SetPredicate_compare_name

func (s *Event_session_predicate_leafContext) SetPredicate_compare_name(v IIdContext)

func (*Event_session_predicate_leafContext) SetPredicate_source_name

func (s *Event_session_predicate_leafContext) SetPredicate_source_name(v IIdContext)

func (*Event_session_predicate_leafContext) ToStringTree

func (s *Event_session_predicate_leafContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Execute_bodyContext

type Execute_bodyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExecute_bodyContext

func NewEmptyExecute_bodyContext() *Execute_bodyContext

func NewExecute_bodyContext

func NewExecute_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_bodyContext

func (*Execute_bodyContext) AS

func (*Execute_bodyContext) AllCOMMA

func (s *Execute_bodyContext) AllCOMMA() []antlr.TerminalNode

func (*Execute_bodyContext) AllExecute_statement_arg

func (s *Execute_bodyContext) AllExecute_statement_arg() []IExecute_statement_argContext

func (*Execute_bodyContext) AllExecute_var_string

func (s *Execute_bodyContext) AllExecute_var_string() []IExecute_var_stringContext

func (*Execute_bodyContext) AllPLUS

func (s *Execute_bodyContext) AllPLUS() []antlr.TerminalNode

func (*Execute_bodyContext) COMMA

func (*Execute_bodyContext) EQUAL

func (*Execute_bodyContext) EnterRule

func (s *Execute_bodyContext) EnterRule(listener antlr.ParseTreeListener)

func (*Execute_bodyContext) Execute_statement_arg

func (s *Execute_bodyContext) Execute_statement_arg(i int) IExecute_statement_argContext

func (*Execute_bodyContext) Execute_var_string

func (s *Execute_bodyContext) Execute_var_string(i int) IExecute_var_stringContext

func (*Execute_bodyContext) ExitRule

func (s *Execute_bodyContext) ExitRule(listener antlr.ParseTreeListener)

func (*Execute_bodyContext) Expression

func (s *Execute_bodyContext) Expression() IExpressionContext

func (*Execute_bodyContext) Func_proc_name_server_database_schema

func (s *Execute_bodyContext) Func_proc_name_server_database_schema() IFunc_proc_name_server_database_schemaContext

func (*Execute_bodyContext) GetParser

func (s *Execute_bodyContext) GetParser() antlr.Parser

func (*Execute_bodyContext) GetReturn_status

func (s *Execute_bodyContext) GetReturn_status() antlr.Token

func (*Execute_bodyContext) GetRuleContext

func (s *Execute_bodyContext) GetRuleContext() antlr.RuleContext

func (*Execute_bodyContext) IsExecute_bodyContext

func (*Execute_bodyContext) IsExecute_bodyContext()

func (*Execute_bodyContext) LOCAL_ID

func (s *Execute_bodyContext) LOCAL_ID() antlr.TerminalNode

func (*Execute_bodyContext) LOGIN

func (*Execute_bodyContext) LR_BRACKET

func (s *Execute_bodyContext) LR_BRACKET() antlr.TerminalNode

func (*Execute_bodyContext) PLUS

func (*Execute_bodyContext) RR_BRACKET

func (s *Execute_bodyContext) RR_BRACKET() antlr.TerminalNode

func (*Execute_bodyContext) SEMI

func (*Execute_bodyContext) STRING

func (*Execute_bodyContext) SetReturn_status

func (s *Execute_bodyContext) SetReturn_status(v antlr.Token)

func (*Execute_bodyContext) ToStringTree

func (s *Execute_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Execute_bodyContext) USER

type Execute_clauseContext

type Execute_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExecute_clauseContext

func NewEmptyExecute_clauseContext() *Execute_clauseContext

func NewExecute_clauseContext

func NewExecute_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_clauseContext

func (*Execute_clauseContext) AS

func (*Execute_clauseContext) CALLER

func (*Execute_clauseContext) EXECUTE

func (*Execute_clauseContext) EnterRule

func (s *Execute_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Execute_clauseContext) ExitRule

func (s *Execute_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Execute_clauseContext) GetClause

func (s *Execute_clauseContext) GetClause() antlr.Token

func (*Execute_clauseContext) GetParser

func (s *Execute_clauseContext) GetParser() antlr.Parser

func (*Execute_clauseContext) GetRuleContext

func (s *Execute_clauseContext) GetRuleContext() antlr.RuleContext

func (*Execute_clauseContext) IsExecute_clauseContext

func (*Execute_clauseContext) IsExecute_clauseContext()

func (*Execute_clauseContext) OWNER

func (*Execute_clauseContext) SELF

func (*Execute_clauseContext) STRING

func (*Execute_clauseContext) SetClause

func (s *Execute_clauseContext) SetClause(v antlr.Token)

func (*Execute_clauseContext) ToStringTree

func (s *Execute_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Execute_statementContext

type Execute_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExecute_statementContext

func NewEmptyExecute_statementContext() *Execute_statementContext

func NewExecute_statementContext

func NewExecute_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_statementContext

func (*Execute_statementContext) EXECUTE

func (*Execute_statementContext) EnterRule

func (s *Execute_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Execute_statementContext) Execute_body

func (*Execute_statementContext) ExitRule

func (s *Execute_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Execute_statementContext) GetParser

func (s *Execute_statementContext) GetParser() antlr.Parser

func (*Execute_statementContext) GetRuleContext

func (s *Execute_statementContext) GetRuleContext() antlr.RuleContext

func (*Execute_statementContext) IsExecute_statementContext

func (*Execute_statementContext) IsExecute_statementContext()

func (*Execute_statementContext) ToStringTree

func (s *Execute_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Execute_statement_argContext

type Execute_statement_argContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExecute_statement_argContext

func NewEmptyExecute_statement_argContext() *Execute_statement_argContext

func NewExecute_statement_argContext

func NewExecute_statement_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_statement_argContext

func (*Execute_statement_argContext) Constant_LOCAL_ID

func (*Execute_statement_argContext) DEFAULT

func (*Execute_statement_argContext) EQUAL

func (*Execute_statement_argContext) EnterRule

func (s *Execute_statement_argContext) EnterRule(listener antlr.ParseTreeListener)

func (*Execute_statement_argContext) ExitRule

func (*Execute_statement_argContext) GetParameter

func (s *Execute_statement_argContext) GetParameter() antlr.Token

func (*Execute_statement_argContext) GetParser

func (s *Execute_statement_argContext) GetParser() antlr.Parser

func (*Execute_statement_argContext) GetRuleContext

func (s *Execute_statement_argContext) GetRuleContext() antlr.RuleContext

func (*Execute_statement_argContext) Id

func (*Execute_statement_argContext) IsExecute_statement_argContext

func (*Execute_statement_argContext) IsExecute_statement_argContext()

func (*Execute_statement_argContext) LOCAL_ID

func (*Execute_statement_argContext) NULL

func (*Execute_statement_argContext) OUT

func (*Execute_statement_argContext) OUTPUT

func (*Execute_statement_argContext) SetParameter

func (s *Execute_statement_argContext) SetParameter(v antlr.Token)

func (*Execute_statement_argContext) ToStringTree

func (s *Execute_statement_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Execute_var_stringContext

type Execute_var_stringContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExecute_var_stringContext

func NewEmptyExecute_var_stringContext() *Execute_var_stringContext

func NewExecute_var_stringContext

func NewExecute_var_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_var_stringContext

func (*Execute_var_stringContext) EnterRule

func (s *Execute_var_stringContext) EnterRule(listener antlr.ParseTreeListener)

func (*Execute_var_stringContext) ExitRule

func (s *Execute_var_stringContext) ExitRule(listener antlr.ParseTreeListener)

func (*Execute_var_stringContext) GetParser

func (s *Execute_var_stringContext) GetParser() antlr.Parser

func (*Execute_var_stringContext) GetRuleContext

func (s *Execute_var_stringContext) GetRuleContext() antlr.RuleContext

func (*Execute_var_stringContext) IsExecute_var_stringContext

func (*Execute_var_stringContext) IsExecute_var_stringContext()

func (*Execute_var_stringContext) LOCAL_ID

func (*Execute_var_stringContext) STRING

func (*Execute_var_stringContext) ToStringTree

func (s *Execute_var_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Exist_methodContext

type Exist_methodContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExist_methodContext

func NewEmptyExist_methodContext() *Exist_methodContext

func NewExist_methodContext

func NewExist_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exist_methodContext

func (*Exist_methodContext) DOT

func (*Exist_methodContext) EXIST

func (*Exist_methodContext) EnterRule

func (s *Exist_methodContext) EnterRule(listener antlr.ParseTreeListener)

func (*Exist_methodContext) ExitRule

func (s *Exist_methodContext) ExitRule(listener antlr.ParseTreeListener)

func (*Exist_methodContext) GetParser

func (s *Exist_methodContext) GetParser() antlr.Parser

func (*Exist_methodContext) GetRuleContext

func (s *Exist_methodContext) GetRuleContext() antlr.RuleContext

func (*Exist_methodContext) GetXquery

func (s *Exist_methodContext) GetXquery() antlr.Token

func (*Exist_methodContext) ID

func (*Exist_methodContext) IsExist_methodContext

func (*Exist_methodContext) IsExist_methodContext()

func (*Exist_methodContext) LOCAL_ID

func (s *Exist_methodContext) LOCAL_ID() antlr.TerminalNode

func (*Exist_methodContext) LR_BRACKET

func (s *Exist_methodContext) LR_BRACKET() antlr.TerminalNode

func (*Exist_methodContext) RR_BRACKET

func (s *Exist_methodContext) RR_BRACKET() antlr.TerminalNode

func (*Exist_methodContext) STRING

func (*Exist_methodContext) SetXquery

func (s *Exist_methodContext) SetXquery(v antlr.Token)

func (*Exist_methodContext) ToStringTree

func (s *Exist_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Existing_keysContext

type Existing_keysContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExisting_keysContext

func NewEmptyExisting_keysContext() *Existing_keysContext

func NewExisting_keysContext

func NewExisting_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Existing_keysContext

func (*Existing_keysContext) ASSEMBLY

func (s *Existing_keysContext) ASSEMBLY() antlr.TerminalNode

func (*Existing_keysContext) EQUAL

func (*Existing_keysContext) EXECUTABLE

func (s *Existing_keysContext) EXECUTABLE() antlr.TerminalNode

func (*Existing_keysContext) EnterRule

func (s *Existing_keysContext) EnterRule(listener antlr.ParseTreeListener)

func (*Existing_keysContext) ExitRule

func (s *Existing_keysContext) ExitRule(listener antlr.ParseTreeListener)

func (*Existing_keysContext) FILE

func (*Existing_keysContext) GetAssembly_name

func (s *Existing_keysContext) GetAssembly_name() IIdContext

func (*Existing_keysContext) GetParser

func (s *Existing_keysContext) GetParser() antlr.Parser

func (*Existing_keysContext) GetPath_to_file

func (s *Existing_keysContext) GetPath_to_file() antlr.Token

func (*Existing_keysContext) GetRuleContext

func (s *Existing_keysContext) GetRuleContext() antlr.RuleContext

func (*Existing_keysContext) Id

func (*Existing_keysContext) IsExisting_keysContext

func (*Existing_keysContext) IsExisting_keysContext()

func (*Existing_keysContext) KEY

func (*Existing_keysContext) LR_BRACKET

func (s *Existing_keysContext) LR_BRACKET() antlr.TerminalNode

func (*Existing_keysContext) PRIVATE

func (*Existing_keysContext) Private_key_options

func (s *Existing_keysContext) Private_key_options() IPrivate_key_optionsContext

func (*Existing_keysContext) RR_BRACKET

func (s *Existing_keysContext) RR_BRACKET() antlr.TerminalNode

func (*Existing_keysContext) STRING

func (*Existing_keysContext) SetAssembly_name

func (s *Existing_keysContext) SetAssembly_name(v IIdContext)

func (*Existing_keysContext) SetPath_to_file

func (s *Existing_keysContext) SetPath_to_file(v antlr.Token)

func (*Existing_keysContext) ToStringTree

func (s *Existing_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Existing_keysContext) WITH

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) AllExpression

func (s *ExpressionContext) AllExpression() []IExpressionContext

func (*ExpressionContext) Assignment_operator

func (s *ExpressionContext) Assignment_operator() IAssignment_operatorContext

func (*ExpressionContext) BIT_AND

func (s *ExpressionContext) BIT_AND() antlr.TerminalNode

func (*ExpressionContext) BIT_OR

func (s *ExpressionContext) BIT_OR() antlr.TerminalNode

func (*ExpressionContext) BIT_XOR

func (s *ExpressionContext) BIT_XOR() antlr.TerminalNode

func (*ExpressionContext) Bracket_expression

func (s *ExpressionContext) Bracket_expression() IBracket_expressionContext

func (*ExpressionContext) COLLATE

func (s *ExpressionContext) COLLATE() antlr.TerminalNode

func (*ExpressionContext) Case_expression

func (s *ExpressionContext) Case_expression() ICase_expressionContext

func (*ExpressionContext) Comparison_operator

func (s *ExpressionContext) Comparison_operator() IComparison_operatorContext

func (*ExpressionContext) DIVIDE

func (s *ExpressionContext) DIVIDE() antlr.TerminalNode

func (*ExpressionContext) DOUBLE_BAR

func (s *ExpressionContext) DOUBLE_BAR() antlr.TerminalNode

func (*ExpressionContext) EnterRule

func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ExpressionContext) ExitRule

func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ExpressionContext) Expression

func (s *ExpressionContext) Expression(i int) IExpressionContext

func (*ExpressionContext) Full_column_name

func (s *ExpressionContext) Full_column_name() IFull_column_nameContext

func (*ExpressionContext) Function_call

func (s *ExpressionContext) Function_call() IFunction_callContext

func (*ExpressionContext) GetOp

func (s *ExpressionContext) GetOp() antlr.Token

func (*ExpressionContext) GetParser

func (s *ExpressionContext) GetParser() antlr.Parser

func (*ExpressionContext) GetRuleContext

func (s *ExpressionContext) GetRuleContext() antlr.RuleContext

func (*ExpressionContext) Id

func (s *ExpressionContext) Id() IIdContext

func (*ExpressionContext) IsExpressionContext

func (*ExpressionContext) IsExpressionContext()

func (*ExpressionContext) MINUS

func (*ExpressionContext) MODULE

func (s *ExpressionContext) MODULE() antlr.TerminalNode

func (*ExpressionContext) Over_clause

func (s *ExpressionContext) Over_clause() IOver_clauseContext

func (*ExpressionContext) PLUS

func (*ExpressionContext) Primitive_expression

func (s *ExpressionContext) Primitive_expression() IPrimitive_expressionContext

func (*ExpressionContext) STAR

func (*ExpressionContext) SetOp

func (s *ExpressionContext) SetOp(v antlr.Token)

func (*ExpressionContext) ToStringTree

func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ExpressionContext) Unary_operator_expression

func (s *ExpressionContext) Unary_operator_expression() IUnary_operator_expressionContext

type Expression_elemContext

type Expression_elemContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpression_elemContext

func NewEmptyExpression_elemContext() *Expression_elemContext

func NewExpression_elemContext

func NewExpression_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_elemContext

func (*Expression_elemContext) As_column_alias

func (s *Expression_elemContext) As_column_alias() IAs_column_aliasContext

func (*Expression_elemContext) Column_alias

func (s *Expression_elemContext) Column_alias() IColumn_aliasContext

func (*Expression_elemContext) EQUAL

func (*Expression_elemContext) EnterRule

func (s *Expression_elemContext) EnterRule(listener antlr.ParseTreeListener)

func (*Expression_elemContext) ExitRule

func (s *Expression_elemContext) ExitRule(listener antlr.ParseTreeListener)

func (*Expression_elemContext) Expression

func (*Expression_elemContext) GetEq

func (s *Expression_elemContext) GetEq() antlr.Token

func (*Expression_elemContext) GetParser

func (s *Expression_elemContext) GetParser() antlr.Parser

func (*Expression_elemContext) GetRuleContext

func (s *Expression_elemContext) GetRuleContext() antlr.RuleContext

func (*Expression_elemContext) IsExpression_elemContext

func (*Expression_elemContext) IsExpression_elemContext()

func (*Expression_elemContext) SetEq

func (s *Expression_elemContext) SetEq(v antlr.Token)

func (*Expression_elemContext) ToStringTree

func (s *Expression_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Expression_listContext

type Expression_listContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpression_listContext

func NewEmptyExpression_listContext() *Expression_listContext

func NewExpression_listContext

func NewExpression_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_listContext

func (*Expression_listContext) AllCOMMA

func (s *Expression_listContext) AllCOMMA() []antlr.TerminalNode

func (*Expression_listContext) AllExpression

func (s *Expression_listContext) AllExpression() []IExpressionContext

func (*Expression_listContext) COMMA

func (*Expression_listContext) EnterRule

func (s *Expression_listContext) EnterRule(listener antlr.ParseTreeListener)

func (*Expression_listContext) ExitRule

func (s *Expression_listContext) ExitRule(listener antlr.ParseTreeListener)

func (*Expression_listContext) Expression

func (*Expression_listContext) GetParser

func (s *Expression_listContext) GetParser() antlr.Parser

func (*Expression_listContext) GetRuleContext

func (s *Expression_listContext) GetRuleContext() antlr.RuleContext

func (*Expression_listContext) IsExpression_listContext

func (*Expression_listContext) IsExpression_listContext()

func (*Expression_listContext) ToStringTree

func (s *Expression_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type External_access_optionContext

type External_access_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExternal_access_optionContext

func NewEmptyExternal_access_optionContext() *External_access_optionContext

func NewExternal_access_optionContext

func NewExternal_access_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_access_optionContext

func (*External_access_optionContext) DB_CHAINING

func (*External_access_optionContext) DECIMAL

func (*External_access_optionContext) DEFAULT_FULLTEXT_LANGUAGE

func (s *External_access_optionContext) DEFAULT_FULLTEXT_LANGUAGE() antlr.TerminalNode

func (*External_access_optionContext) DEFAULT_LANGUAGE

func (s *External_access_optionContext) DEFAULT_LANGUAGE() antlr.TerminalNode

func (*External_access_optionContext) EQUAL

func (*External_access_optionContext) EnterRule

func (s *External_access_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*External_access_optionContext) ExitRule

func (*External_access_optionContext) GetParser

func (*External_access_optionContext) GetRuleContext

func (s *External_access_optionContext) GetRuleContext() antlr.RuleContext

func (*External_access_optionContext) Id

func (*External_access_optionContext) IsExternal_access_optionContext

func (*External_access_optionContext) IsExternal_access_optionContext()

func (*External_access_optionContext) NESTED_TRIGGERS

func (s *External_access_optionContext) NESTED_TRIGGERS() antlr.TerminalNode

func (*External_access_optionContext) OFF

func (*External_access_optionContext) ON

func (*External_access_optionContext) On_off

func (*External_access_optionContext) STRING

func (*External_access_optionContext) TRANSFORM_NOISE_WORDS

func (s *External_access_optionContext) TRANSFORM_NOISE_WORDS() antlr.TerminalNode

func (*External_access_optionContext) TRUSTWORTHY

func (*External_access_optionContext) TWO_DIGIT_YEAR_CUTOFF

func (s *External_access_optionContext) TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode

func (*External_access_optionContext) ToStringTree

func (s *External_access_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Fetch_cursorContext

type Fetch_cursorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFetch_cursorContext

func NewEmptyFetch_cursorContext() *Fetch_cursorContext

func NewFetch_cursorContext

func NewFetch_cursorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fetch_cursorContext

func (*Fetch_cursorContext) ABSOLUTE

func (s *Fetch_cursorContext) ABSOLUTE() antlr.TerminalNode

func (*Fetch_cursorContext) AllCOMMA

func (s *Fetch_cursorContext) AllCOMMA() []antlr.TerminalNode

func (*Fetch_cursorContext) AllLOCAL_ID

func (s *Fetch_cursorContext) AllLOCAL_ID() []antlr.TerminalNode

func (*Fetch_cursorContext) COMMA

func (*Fetch_cursorContext) Cursor_name

func (s *Fetch_cursorContext) Cursor_name() ICursor_nameContext

func (*Fetch_cursorContext) EnterRule

func (s *Fetch_cursorContext) EnterRule(listener antlr.ParseTreeListener)

func (*Fetch_cursorContext) ExitRule

func (s *Fetch_cursorContext) ExitRule(listener antlr.ParseTreeListener)

func (*Fetch_cursorContext) Expression

func (s *Fetch_cursorContext) Expression() IExpressionContext

func (*Fetch_cursorContext) FETCH

func (*Fetch_cursorContext) FIRST

func (*Fetch_cursorContext) FROM

func (*Fetch_cursorContext) GLOBAL

func (*Fetch_cursorContext) GetParser

func (s *Fetch_cursorContext) GetParser() antlr.Parser

func (*Fetch_cursorContext) GetRuleContext

func (s *Fetch_cursorContext) GetRuleContext() antlr.RuleContext

func (*Fetch_cursorContext) INTO

func (*Fetch_cursorContext) IsFetch_cursorContext

func (*Fetch_cursorContext) IsFetch_cursorContext()

func (*Fetch_cursorContext) LAST

func (*Fetch_cursorContext) LOCAL_ID

func (s *Fetch_cursorContext) LOCAL_ID(i int) antlr.TerminalNode

func (*Fetch_cursorContext) NEXT

func (*Fetch_cursorContext) PRIOR

func (*Fetch_cursorContext) RELATIVE

func (s *Fetch_cursorContext) RELATIVE() antlr.TerminalNode

func (*Fetch_cursorContext) SEMI

func (*Fetch_cursorContext) ToStringTree

func (s *Fetch_cursorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type File_directory_path_separatorContext

type File_directory_path_separatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFile_directory_path_separatorContext

func NewEmptyFile_directory_path_separatorContext() *File_directory_path_separatorContext

func NewFile_directory_path_separatorContext

func NewFile_directory_path_separatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_directory_path_separatorContext

func (*File_directory_path_separatorContext) BACKSLASH

func (*File_directory_path_separatorContext) EnterRule

func (*File_directory_path_separatorContext) ExitRule

func (*File_directory_path_separatorContext) GetParser

func (*File_directory_path_separatorContext) GetRuleContext

func (*File_directory_path_separatorContext) IsFile_directory_path_separatorContext

func (*File_directory_path_separatorContext) IsFile_directory_path_separatorContext()

func (*File_directory_path_separatorContext) ToStringTree

func (s *File_directory_path_separatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type File_groupContext

type File_groupContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFile_groupContext

func NewEmptyFile_groupContext() *File_groupContext

func NewFile_groupContext

func NewFile_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_groupContext

func (*File_groupContext) AllCOMMA

func (s *File_groupContext) AllCOMMA() []antlr.TerminalNode

func (*File_groupContext) AllCONTAINS

func (s *File_groupContext) AllCONTAINS() []antlr.TerminalNode

func (*File_groupContext) AllFile_spec

func (s *File_groupContext) AllFile_spec() []IFile_specContext

func (*File_groupContext) COMMA

func (*File_groupContext) CONTAINS

func (s *File_groupContext) CONTAINS(i int) antlr.TerminalNode

func (*File_groupContext) DEFAULT

func (s *File_groupContext) DEFAULT() antlr.TerminalNode

func (*File_groupContext) EnterRule

func (s *File_groupContext) EnterRule(listener antlr.ParseTreeListener)

func (*File_groupContext) ExitRule

func (s *File_groupContext) ExitRule(listener antlr.ParseTreeListener)

func (*File_groupContext) FILEGROUP

func (s *File_groupContext) FILEGROUP() antlr.TerminalNode

func (*File_groupContext) FILESTREAM

func (s *File_groupContext) FILESTREAM() antlr.TerminalNode

func (*File_groupContext) File_spec

func (s *File_groupContext) File_spec(i int) IFile_specContext

func (*File_groupContext) GetParser

func (s *File_groupContext) GetParser() antlr.Parser

func (*File_groupContext) GetRuleContext

func (s *File_groupContext) GetRuleContext() antlr.RuleContext

func (*File_groupContext) Id

func (s *File_groupContext) Id() IIdContext

func (*File_groupContext) IsFile_groupContext

func (*File_groupContext) IsFile_groupContext()

func (*File_groupContext) MEMORY_OPTIMIZED_DATA

func (s *File_groupContext) MEMORY_OPTIMIZED_DATA() antlr.TerminalNode

func (*File_groupContext) ToStringTree

func (s *File_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type File_pathContext

type File_pathContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFile_pathContext

func NewEmptyFile_pathContext() *File_pathContext

func NewFile_pathContext

func NewFile_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_pathContext

func (*File_pathContext) EnterRule

func (s *File_pathContext) EnterRule(listener antlr.ParseTreeListener)

func (*File_pathContext) ExitRule

func (s *File_pathContext) ExitRule(listener antlr.ParseTreeListener)

func (*File_pathContext) File_directory_path_separator

func (s *File_pathContext) File_directory_path_separator() IFile_directory_path_separatorContext

func (*File_pathContext) File_path

func (s *File_pathContext) File_path() IFile_pathContext

func (*File_pathContext) GetParser

func (s *File_pathContext) GetParser() antlr.Parser

func (*File_pathContext) GetRuleContext

func (s *File_pathContext) GetRuleContext() antlr.RuleContext

func (*File_pathContext) Id

func (s *File_pathContext) Id() IIdContext

func (*File_pathContext) IsFile_pathContext

func (*File_pathContext) IsFile_pathContext()

func (*File_pathContext) ToStringTree

func (s *File_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type File_sizeContext

type File_sizeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFile_sizeContext

func NewEmptyFile_sizeContext() *File_sizeContext

func NewFile_sizeContext

func NewFile_sizeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_sizeContext

func (*File_sizeContext) DECIMAL

func (s *File_sizeContext) DECIMAL() antlr.TerminalNode

func (*File_sizeContext) EnterRule

func (s *File_sizeContext) EnterRule(listener antlr.ParseTreeListener)

func (*File_sizeContext) ExitRule

func (s *File_sizeContext) ExitRule(listener antlr.ParseTreeListener)

func (*File_sizeContext) GB

func (*File_sizeContext) GetParser

func (s *File_sizeContext) GetParser() antlr.Parser

func (*File_sizeContext) GetRuleContext

func (s *File_sizeContext) GetRuleContext() antlr.RuleContext

func (*File_sizeContext) IsFile_sizeContext

func (*File_sizeContext) IsFile_sizeContext()

func (*File_sizeContext) KB

func (*File_sizeContext) MB

func (*File_sizeContext) MODULE

func (s *File_sizeContext) MODULE() antlr.TerminalNode

func (*File_sizeContext) TB

func (*File_sizeContext) ToStringTree

func (s *File_sizeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type File_specContext

type File_specContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFile_specContext

func NewEmptyFile_specContext() *File_specContext

func NewFile_specContext

func NewFile_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_specContext

func (*File_specContext) AllCOMMA

func (s *File_specContext) AllCOMMA() []antlr.TerminalNode

func (*File_specContext) AllEQUAL

func (s *File_specContext) AllEQUAL() []antlr.TerminalNode

func (*File_specContext) AllFile_size

func (s *File_specContext) AllFile_size() []IFile_sizeContext

func (*File_specContext) AllSTRING

func (s *File_specContext) AllSTRING() []antlr.TerminalNode

func (*File_specContext) COMMA

func (s *File_specContext) COMMA(i int) antlr.TerminalNode

func (*File_specContext) EQUAL

func (s *File_specContext) EQUAL(i int) antlr.TerminalNode

func (*File_specContext) EnterRule

func (s *File_specContext) EnterRule(listener antlr.ParseTreeListener)

func (*File_specContext) ExitRule

func (s *File_specContext) ExitRule(listener antlr.ParseTreeListener)

func (*File_specContext) FILEGROWTH

func (s *File_specContext) FILEGROWTH() antlr.TerminalNode

func (*File_specContext) FILENAME

func (s *File_specContext) FILENAME() antlr.TerminalNode

func (*File_specContext) File_size

func (s *File_specContext) File_size(i int) IFile_sizeContext

func (*File_specContext) GetFile

func (s *File_specContext) GetFile() antlr.Token

func (*File_specContext) GetParser

func (s *File_specContext) GetParser() antlr.Parser

func (*File_specContext) GetRuleContext

func (s *File_specContext) GetRuleContext() antlr.RuleContext

func (*File_specContext) Id

func (s *File_specContext) Id() IIdContext

func (*File_specContext) IsFile_specContext

func (*File_specContext) IsFile_specContext()

func (*File_specContext) LR_BRACKET

func (s *File_specContext) LR_BRACKET() antlr.TerminalNode

func (*File_specContext) MAXSIZE

func (s *File_specContext) MAXSIZE() antlr.TerminalNode

func (*File_specContext) NAME

func (*File_specContext) RR_BRACKET

func (s *File_specContext) RR_BRACKET() antlr.TerminalNode

func (*File_specContext) SIZE

func (*File_specContext) STRING

func (s *File_specContext) STRING(i int) antlr.TerminalNode

func (*File_specContext) SetFile

func (s *File_specContext) SetFile(v antlr.Token)

func (*File_specContext) ToStringTree

func (s *File_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*File_specContext) UNLIMITED

func (s *File_specContext) UNLIMITED() antlr.TerminalNode

type For_clauseContext

type For_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFor_clauseContext

func NewEmptyFor_clauseContext() *For_clauseContext

func NewFor_clauseContext

func NewFor_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_clauseContext

func (*For_clauseContext) ABSENT

func (s *For_clauseContext) ABSENT() antlr.TerminalNode

func (*For_clauseContext) AUTO

func (*For_clauseContext) AllCOMMA

func (s *For_clauseContext) AllCOMMA() []antlr.TerminalNode

func (*For_clauseContext) AllLR_BRACKET

func (s *For_clauseContext) AllLR_BRACKET() []antlr.TerminalNode

func (*For_clauseContext) AllRR_BRACKET

func (s *For_clauseContext) AllRR_BRACKET() []antlr.TerminalNode

func (*For_clauseContext) AllSTRING

func (s *For_clauseContext) AllSTRING() []antlr.TerminalNode

func (*For_clauseContext) AllXml_common_directives

func (s *For_clauseContext) AllXml_common_directives() []IXml_common_directivesContext

func (*For_clauseContext) BROWSE

func (s *For_clauseContext) BROWSE() antlr.TerminalNode

func (*For_clauseContext) COMMA

func (*For_clauseContext) ELEMENTS

func (s *For_clauseContext) ELEMENTS() antlr.TerminalNode

func (*For_clauseContext) EXPLICIT

func (s *For_clauseContext) EXPLICIT() antlr.TerminalNode

func (*For_clauseContext) EnterRule

func (s *For_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*For_clauseContext) ExitRule

func (s *For_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*For_clauseContext) FOR

func (*For_clauseContext) GetParser

func (s *For_clauseContext) GetParser() antlr.Parser

func (*For_clauseContext) GetRuleContext

func (s *For_clauseContext) GetRuleContext() antlr.RuleContext

func (*For_clauseContext) INCLUDE_NULL_VALUES

func (s *For_clauseContext) INCLUDE_NULL_VALUES() antlr.TerminalNode

func (*For_clauseContext) IsFor_clauseContext

func (*For_clauseContext) IsFor_clauseContext()

func (*For_clauseContext) JSON

func (*For_clauseContext) LR_BRACKET

func (s *For_clauseContext) LR_BRACKET(i int) antlr.TerminalNode

func (*For_clauseContext) PATH

func (*For_clauseContext) RAW

func (*For_clauseContext) ROOT

func (*For_clauseContext) RR_BRACKET

func (s *For_clauseContext) RR_BRACKET(i int) antlr.TerminalNode

func (*For_clauseContext) STRING

func (s *For_clauseContext) STRING(i int) antlr.TerminalNode

func (*For_clauseContext) ToStringTree

func (s *For_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*For_clauseContext) WITHOUT_ARRAY_WRAPPER

func (s *For_clauseContext) WITHOUT_ARRAY_WRAPPER() antlr.TerminalNode

func (*For_clauseContext) XML

func (*For_clauseContext) XMLDATA

func (s *For_clauseContext) XMLDATA() antlr.TerminalNode

func (*For_clauseContext) XMLSCHEMA

func (s *For_clauseContext) XMLSCHEMA() antlr.TerminalNode

func (*For_clauseContext) XSINIL

func (s *For_clauseContext) XSINIL() antlr.TerminalNode

func (*For_clauseContext) Xml_common_directives

func (s *For_clauseContext) Xml_common_directives(i int) IXml_common_directivesContext

type Full_column_nameContext

type Full_column_nameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFull_column_nameContext

func NewEmptyFull_column_nameContext() *Full_column_nameContext

func NewFull_column_nameContext

func NewFull_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_column_nameContext

func (*Full_column_nameContext) ANSI_NULLS

func (s *Full_column_nameContext) ANSI_NULLS() antlr.TerminalNode

func (*Full_column_nameContext) ANSI_PADDING

func (s *Full_column_nameContext) ANSI_PADDING() antlr.TerminalNode

func (*Full_column_nameContext) ANSI_WARNINGS

func (s *Full_column_nameContext) ANSI_WARNINGS() antlr.TerminalNode

func (*Full_column_nameContext) ARITHABORT

func (s *Full_column_nameContext) ARITHABORT() antlr.TerminalNode

func (*Full_column_nameContext) COMPATIBILITY_LEVEL

func (s *Full_column_nameContext) COMPATIBILITY_LEVEL() antlr.TerminalNode

func (*Full_column_nameContext) DOT

func (*Full_column_nameContext) EnterRule

func (s *Full_column_nameContext) EnterRule(listener antlr.ParseTreeListener)

func (*Full_column_nameContext) ExitRule

func (s *Full_column_nameContext) ExitRule(listener antlr.ParseTreeListener)

func (*Full_column_nameContext) GetColumn_name

func (s *Full_column_nameContext) GetColumn_name() IIdContext

func (*Full_column_nameContext) GetParser

func (s *Full_column_nameContext) GetParser() antlr.Parser

func (*Full_column_nameContext) GetRuleContext

func (s *Full_column_nameContext) GetRuleContext() antlr.RuleContext

func (*Full_column_nameContext) Id

func (*Full_column_nameContext) IsFull_column_nameContext

func (*Full_column_nameContext) IsFull_column_nameContext()

func (*Full_column_nameContext) QUOTED_IDENTIFIER

func (s *Full_column_nameContext) QUOTED_IDENTIFIER() antlr.TerminalNode

func (*Full_column_nameContext) STATUS

func (*Full_column_nameContext) SetColumn_name

func (s *Full_column_nameContext) SetColumn_name(v IIdContext)

func (*Full_column_nameContext) Table_name

func (*Full_column_nameContext) ToStringTree

func (s *Full_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Full_column_name_listContext

type Full_column_name_listContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFull_column_name_listContext

func NewEmptyFull_column_name_listContext() *Full_column_name_listContext

func NewFull_column_name_listContext

func NewFull_column_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_column_name_listContext

func (*Full_column_name_listContext) AllCOMMA

func (*Full_column_name_listContext) AllFull_column_name

func (s *Full_column_name_listContext) AllFull_column_name() []IFull_column_nameContext

func (*Full_column_name_listContext) COMMA

func (*Full_column_name_listContext) EnterRule

func (s *Full_column_name_listContext) EnterRule(listener antlr.ParseTreeListener)

func (*Full_column_name_listContext) ExitRule

func (*Full_column_name_listContext) Full_column_name

func (*Full_column_name_listContext) GetParser

func (s *Full_column_name_listContext) GetParser() antlr.Parser

func (*Full_column_name_listContext) GetRuleContext

func (s *Full_column_name_listContext) GetRuleContext() antlr.RuleContext

func (*Full_column_name_listContext) IsFull_column_name_listContext

func (*Full_column_name_listContext) IsFull_column_name_listContext()

func (*Full_column_name_listContext) ToStringTree

func (s *Full_column_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Full_table_nameContext

type Full_table_nameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFull_table_nameContext

func NewEmptyFull_table_nameContext() *Full_table_nameContext

func NewFull_table_nameContext

func NewFull_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_table_nameContext

func (*Full_table_nameContext) AllDOT

func (*Full_table_nameContext) AllId

func (s *Full_table_nameContext) AllId() []IIdContext

func (*Full_table_nameContext) DOT

func (*Full_table_nameContext) EnterRule

func (s *Full_table_nameContext) EnterRule(listener antlr.ParseTreeListener)

func (*Full_table_nameContext) ExitRule

func (s *Full_table_nameContext) ExitRule(listener antlr.ParseTreeListener)

func (*Full_table_nameContext) GetDatabase

func (s *Full_table_nameContext) GetDatabase() IIdContext

func (*Full_table_nameContext) GetParser

func (s *Full_table_nameContext) GetParser() antlr.Parser

func (*Full_table_nameContext) GetRuleContext

func (s *Full_table_nameContext) GetRuleContext() antlr.RuleContext

func (*Full_table_nameContext) GetSchema

func (s *Full_table_nameContext) GetSchema() IIdContext

func (*Full_table_nameContext) GetServer

func (s *Full_table_nameContext) GetServer() IIdContext

func (*Full_table_nameContext) GetTable

func (s *Full_table_nameContext) GetTable() IIdContext

func (*Full_table_nameContext) Id

func (*Full_table_nameContext) IsFull_table_nameContext

func (*Full_table_nameContext) IsFull_table_nameContext()

func (*Full_table_nameContext) SetDatabase

func (s *Full_table_nameContext) SetDatabase(v IIdContext)

func (*Full_table_nameContext) SetSchema

func (s *Full_table_nameContext) SetSchema(v IIdContext)

func (*Full_table_nameContext) SetServer

func (s *Full_table_nameContext) SetServer(v IIdContext)

func (*Full_table_nameContext) SetTable

func (s *Full_table_nameContext) SetTable(v IIdContext)

func (*Full_table_nameContext) ToStringTree

func (s *Full_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Func_body_returns_scalarContext

type Func_body_returns_scalarContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunc_body_returns_scalarContext

func NewEmptyFunc_body_returns_scalarContext() *Func_body_returns_scalarContext

func NewFunc_body_returns_scalarContext

func NewFunc_body_returns_scalarContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_body_returns_scalarContext

func (*Func_body_returns_scalarContext) AS

func (*Func_body_returns_scalarContext) AllCOMMA

func (*Func_body_returns_scalarContext) AllFunction_option

func (s *Func_body_returns_scalarContext) AllFunction_option() []IFunction_optionContext

func (*Func_body_returns_scalarContext) AllSql_clause

func (*Func_body_returns_scalarContext) BEGIN

func (*Func_body_returns_scalarContext) COMMA

func (*Func_body_returns_scalarContext) Data_type

func (*Func_body_returns_scalarContext) END

func (*Func_body_returns_scalarContext) EnterRule

func (*Func_body_returns_scalarContext) ExitRule

func (*Func_body_returns_scalarContext) Expression

func (*Func_body_returns_scalarContext) Function_option

func (*Func_body_returns_scalarContext) GetParser

func (*Func_body_returns_scalarContext) GetRet

func (*Func_body_returns_scalarContext) GetRuleContext

func (*Func_body_returns_scalarContext) IsFunc_body_returns_scalarContext

func (*Func_body_returns_scalarContext) IsFunc_body_returns_scalarContext()

func (*Func_body_returns_scalarContext) RETURN

func (*Func_body_returns_scalarContext) RETURNS

func (*Func_body_returns_scalarContext) SEMI

func (*Func_body_returns_scalarContext) SetRet

func (*Func_body_returns_scalarContext) Sql_clause

func (*Func_body_returns_scalarContext) ToStringTree

func (s *Func_body_returns_scalarContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Func_body_returns_scalarContext) WITH

type Func_body_returns_selectContext

type Func_body_returns_selectContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunc_body_returns_selectContext

func NewEmptyFunc_body_returns_selectContext() *Func_body_returns_selectContext

func NewFunc_body_returns_selectContext

func NewFunc_body_returns_selectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_body_returns_selectContext

func (*Func_body_returns_selectContext) AS

func (*Func_body_returns_selectContext) AllCOMMA

func (*Func_body_returns_selectContext) AllFunction_option

func (s *Func_body_returns_selectContext) AllFunction_option() []IFunction_optionContext

func (*Func_body_returns_selectContext) COMMA

func (*Func_body_returns_selectContext) EnterRule

func (*Func_body_returns_selectContext) ExitRule

func (*Func_body_returns_selectContext) Function_option

func (*Func_body_returns_selectContext) GetParser

func (*Func_body_returns_selectContext) GetRuleContext

func (*Func_body_returns_selectContext) IsFunc_body_returns_selectContext

func (*Func_body_returns_selectContext) IsFunc_body_returns_selectContext()

func (*Func_body_returns_selectContext) LR_BRACKET

func (*Func_body_returns_selectContext) RETURN

func (*Func_body_returns_selectContext) RETURNS

func (*Func_body_returns_selectContext) RR_BRACKET

func (*Func_body_returns_selectContext) Select_statement

func (*Func_body_returns_selectContext) TABLE

func (*Func_body_returns_selectContext) ToStringTree

func (s *Func_body_returns_selectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Func_body_returns_selectContext) WITH

type Func_body_returns_tableContext

type Func_body_returns_tableContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunc_body_returns_tableContext

func NewEmptyFunc_body_returns_tableContext() *Func_body_returns_tableContext

func NewFunc_body_returns_tableContext

func NewFunc_body_returns_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_body_returns_tableContext

func (*Func_body_returns_tableContext) AS

func (*Func_body_returns_tableContext) AllCOMMA

func (*Func_body_returns_tableContext) AllFunction_option

func (s *Func_body_returns_tableContext) AllFunction_option() []IFunction_optionContext

func (*Func_body_returns_tableContext) AllSEMI

func (*Func_body_returns_tableContext) AllSql_clause

func (*Func_body_returns_tableContext) BEGIN

func (*Func_body_returns_tableContext) COMMA

func (*Func_body_returns_tableContext) END

func (*Func_body_returns_tableContext) EnterRule

func (*Func_body_returns_tableContext) ExitRule

func (*Func_body_returns_tableContext) Function_option

func (*Func_body_returns_tableContext) GetParser

func (*Func_body_returns_tableContext) GetRuleContext

func (s *Func_body_returns_tableContext) GetRuleContext() antlr.RuleContext

func (*Func_body_returns_tableContext) IsFunc_body_returns_tableContext

func (*Func_body_returns_tableContext) IsFunc_body_returns_tableContext()

func (*Func_body_returns_tableContext) LOCAL_ID

func (*Func_body_returns_tableContext) RETURN

func (*Func_body_returns_tableContext) RETURNS

func (*Func_body_returns_tableContext) SEMI

func (*Func_body_returns_tableContext) Sql_clause

func (*Func_body_returns_tableContext) Table_type_definition

func (*Func_body_returns_tableContext) ToStringTree

func (s *Func_body_returns_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Func_body_returns_tableContext) WITH

type Func_proc_name_database_schemaContext

type Func_proc_name_database_schemaContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunc_proc_name_database_schemaContext

func NewEmptyFunc_proc_name_database_schemaContext() *Func_proc_name_database_schemaContext

func NewFunc_proc_name_database_schemaContext

func NewFunc_proc_name_database_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_proc_name_database_schemaContext

func (*Func_proc_name_database_schemaContext) AllDOT

func (*Func_proc_name_database_schemaContext) AllId

func (*Func_proc_name_database_schemaContext) DOT

func (*Func_proc_name_database_schemaContext) EnterRule

func (*Func_proc_name_database_schemaContext) ExitRule

func (*Func_proc_name_database_schemaContext) Func_proc_name_schema

func (*Func_proc_name_database_schemaContext) GetDatabase

func (*Func_proc_name_database_schemaContext) GetParser

func (*Func_proc_name_database_schemaContext) GetProcedure

func (*Func_proc_name_database_schemaContext) GetRuleContext

func (*Func_proc_name_database_schemaContext) GetSchema

func (*Func_proc_name_database_schemaContext) Id

func (*Func_proc_name_database_schemaContext) IsFunc_proc_name_database_schemaContext

func (*Func_proc_name_database_schemaContext) IsFunc_proc_name_database_schemaContext()

func (*Func_proc_name_database_schemaContext) SetDatabase

func (*Func_proc_name_database_schemaContext) SetProcedure

func (*Func_proc_name_database_schemaContext) SetSchema

func (*Func_proc_name_database_schemaContext) ToStringTree

func (s *Func_proc_name_database_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Func_proc_name_schemaContext

type Func_proc_name_schemaContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunc_proc_name_schemaContext

func NewEmptyFunc_proc_name_schemaContext() *Func_proc_name_schemaContext

func NewFunc_proc_name_schemaContext

func NewFunc_proc_name_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_proc_name_schemaContext

func (*Func_proc_name_schemaContext) AllId

func (*Func_proc_name_schemaContext) DOT

func (*Func_proc_name_schemaContext) EnterRule

func (s *Func_proc_name_schemaContext) EnterRule(listener antlr.ParseTreeListener)

func (*Func_proc_name_schemaContext) ExitRule

func (*Func_proc_name_schemaContext) GetParser

func (s *Func_proc_name_schemaContext) GetParser() antlr.Parser

func (*Func_proc_name_schemaContext) GetProcedure

func (s *Func_proc_name_schemaContext) GetProcedure() IIdContext

func (*Func_proc_name_schemaContext) GetRuleContext

func (s *Func_proc_name_schemaContext) GetRuleContext() antlr.RuleContext

func (*Func_proc_name_schemaContext) GetSchema

func (*Func_proc_name_schemaContext) Id

func (*Func_proc_name_schemaContext) IsFunc_proc_name_schemaContext

func (*Func_proc_name_schemaContext) IsFunc_proc_name_schemaContext()

func (*Func_proc_name_schemaContext) SetProcedure

func (s *Func_proc_name_schemaContext) SetProcedure(v IIdContext)

func (*Func_proc_name_schemaContext) SetSchema

func (s *Func_proc_name_schemaContext) SetSchema(v IIdContext)

func (*Func_proc_name_schemaContext) ToStringTree

func (s *Func_proc_name_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Func_proc_name_server_database_schemaContext

type Func_proc_name_server_database_schemaContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunc_proc_name_server_database_schemaContext

func NewEmptyFunc_proc_name_server_database_schemaContext() *Func_proc_name_server_database_schemaContext

func NewFunc_proc_name_server_database_schemaContext

func NewFunc_proc_name_server_database_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_proc_name_server_database_schemaContext

func (*Func_proc_name_server_database_schemaContext) AllDOT

func (*Func_proc_name_server_database_schemaContext) AllId

func (*Func_proc_name_server_database_schemaContext) DOT

func (*Func_proc_name_server_database_schemaContext) EnterRule

func (*Func_proc_name_server_database_schemaContext) ExitRule

func (*Func_proc_name_server_database_schemaContext) Func_proc_name_database_schema

func (*Func_proc_name_server_database_schemaContext) GetDatabase

func (*Func_proc_name_server_database_schemaContext) GetParser

func (*Func_proc_name_server_database_schemaContext) GetProcedure

func (*Func_proc_name_server_database_schemaContext) GetRuleContext

func (*Func_proc_name_server_database_schemaContext) GetSchema

func (*Func_proc_name_server_database_schemaContext) GetServer

func (*Func_proc_name_server_database_schemaContext) Id

func (*Func_proc_name_server_database_schemaContext) IsFunc_proc_name_server_database_schemaContext

func (*Func_proc_name_server_database_schemaContext) IsFunc_proc_name_server_database_schemaContext()

func (*Func_proc_name_server_database_schemaContext) SetDatabase

func (*Func_proc_name_server_database_schemaContext) SetProcedure

func (*Func_proc_name_server_database_schemaContext) SetSchema

func (*Func_proc_name_server_database_schemaContext) SetServer

func (*Func_proc_name_server_database_schemaContext) ToStringTree

func (s *Func_proc_name_server_database_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Function_callContext

type Function_callContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunction_callContext

func NewEmptyFunction_callContext() *Function_callContext

func NewFunction_callContext

func NewFunction_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_callContext

func (*Function_callContext) CopyFrom

func (s *Function_callContext) CopyFrom(ctx *Function_callContext)

func (*Function_callContext) GetParser

func (s *Function_callContext) GetParser() antlr.Parser

func (*Function_callContext) GetRuleContext

func (s *Function_callContext) GetRuleContext() antlr.RuleContext

func (*Function_callContext) IsFunction_callContext

func (*Function_callContext) IsFunction_callContext()

func (*Function_callContext) ToStringTree

func (s *Function_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Function_optionContext

type Function_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunction_optionContext

func NewEmptyFunction_optionContext() *Function_optionContext

func NewFunction_optionContext

func NewFunction_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_optionContext

func (*Function_optionContext) AllNULL

func (s *Function_optionContext) AllNULL() []antlr.TerminalNode

func (*Function_optionContext) CALLED

func (*Function_optionContext) ENCRYPTION

func (s *Function_optionContext) ENCRYPTION() antlr.TerminalNode

func (*Function_optionContext) EnterRule

func (s *Function_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Function_optionContext) Execute_clause

func (s *Function_optionContext) Execute_clause() IExecute_clauseContext

func (*Function_optionContext) ExitRule

func (s *Function_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Function_optionContext) GetParser

func (s *Function_optionContext) GetParser() antlr.Parser

func (*Function_optionContext) GetRuleContext

func (s *Function_optionContext) GetRuleContext() antlr.RuleContext

func (*Function_optionContext) INPUT

func (*Function_optionContext) IsFunction_optionContext

func (*Function_optionContext) IsFunction_optionContext()

func (*Function_optionContext) NULL

func (*Function_optionContext) ON

func (*Function_optionContext) RETURNS

func (*Function_optionContext) SCHEMABINDING

func (s *Function_optionContext) SCHEMABINDING() antlr.TerminalNode

func (*Function_optionContext) ToStringTree

func (s *Function_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type GETDATEContext

type GETDATEContext struct {
	*Function_callContext
}

func NewGETDATEContext

func NewGETDATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GETDATEContext

func (*GETDATEContext) EnterRule

func (s *GETDATEContext) EnterRule(listener antlr.ParseTreeListener)

func (*GETDATEContext) ExitRule

func (s *GETDATEContext) ExitRule(listener antlr.ParseTreeListener)

func (*GETDATEContext) GETDATE

func (s *GETDATEContext) GETDATE() antlr.TerminalNode

func (*GETDATEContext) GetRuleContext

func (s *GETDATEContext) GetRuleContext() antlr.RuleContext

func (*GETDATEContext) LR_BRACKET

func (s *GETDATEContext) LR_BRACKET() antlr.TerminalNode

func (*GETDATEContext) RR_BRACKET

func (s *GETDATEContext) RR_BRACKET() antlr.TerminalNode

type GETUTCDATEContext

type GETUTCDATEContext struct {
	*Function_callContext
}

func NewGETUTCDATEContext

func NewGETUTCDATEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GETUTCDATEContext

func (*GETUTCDATEContext) EnterRule

func (s *GETUTCDATEContext) EnterRule(listener antlr.ParseTreeListener)

func (*GETUTCDATEContext) ExitRule

func (s *GETUTCDATEContext) ExitRule(listener antlr.ParseTreeListener)

func (*GETUTCDATEContext) GETUTCDATE

func (s *GETUTCDATEContext) GETUTCDATE() antlr.TerminalNode

func (*GETUTCDATEContext) GetRuleContext

func (s *GETUTCDATEContext) GetRuleContext() antlr.RuleContext

func (*GETUTCDATEContext) LR_BRACKET

func (s *GETUTCDATEContext) LR_BRACKET() antlr.TerminalNode

func (*GETUTCDATEContext) RR_BRACKET

func (s *GETUTCDATEContext) RR_BRACKET() antlr.TerminalNode

type Generate_new_keysContext

type Generate_new_keysContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyGenerate_new_keysContext

func NewEmptyGenerate_new_keysContext() *Generate_new_keysContext

func NewGenerate_new_keysContext

func NewGenerate_new_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generate_new_keysContext

func (*Generate_new_keysContext) AllCOMMA

func (*Generate_new_keysContext) AllDate_options

func (s *Generate_new_keysContext) AllDate_options() []IDate_optionsContext

func (*Generate_new_keysContext) AllEQUAL

func (*Generate_new_keysContext) AllSTRING

func (s *Generate_new_keysContext) AllSTRING() []antlr.TerminalNode

func (*Generate_new_keysContext) BY

func (*Generate_new_keysContext) COMMA

func (*Generate_new_keysContext) Date_options

func (*Generate_new_keysContext) ENCRYPTION

func (*Generate_new_keysContext) EQUAL

func (*Generate_new_keysContext) EnterRule

func (s *Generate_new_keysContext) EnterRule(listener antlr.ParseTreeListener)

func (*Generate_new_keysContext) ExitRule

func (s *Generate_new_keysContext) ExitRule(listener antlr.ParseTreeListener)

func (*Generate_new_keysContext) GetCertificate_subject_name

func (s *Generate_new_keysContext) GetCertificate_subject_name() antlr.Token

func (*Generate_new_keysContext) GetParser

func (s *Generate_new_keysContext) GetParser() antlr.Parser

func (*Generate_new_keysContext) GetPassword

func (s *Generate_new_keysContext) GetPassword() antlr.Token

func (*Generate_new_keysContext) GetRuleContext

func (s *Generate_new_keysContext) GetRuleContext() antlr.RuleContext

func (*Generate_new_keysContext) IsGenerate_new_keysContext

func (*Generate_new_keysContext) IsGenerate_new_keysContext()

func (*Generate_new_keysContext) PASSWORD

func (*Generate_new_keysContext) STRING

func (*Generate_new_keysContext) SUBJECT

func (*Generate_new_keysContext) SetCertificate_subject_name

func (s *Generate_new_keysContext) SetCertificate_subject_name(v antlr.Token)

func (*Generate_new_keysContext) SetPassword

func (s *Generate_new_keysContext) SetPassword(v antlr.Token)

func (*Generate_new_keysContext) ToStringTree

func (s *Generate_new_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Generate_new_keysContext) WITH

type Get_conversationContext

type Get_conversationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyGet_conversationContext

func NewEmptyGet_conversationContext() *Get_conversationContext

func NewGet_conversationContext

func NewGet_conversationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Get_conversationContext

func (*Get_conversationContext) CONVERSATION

func (s *Get_conversationContext) CONVERSATION() antlr.TerminalNode

func (*Get_conversationContext) EnterRule

func (s *Get_conversationContext) EnterRule(listener antlr.ParseTreeListener)

func (*Get_conversationContext) ExitRule

func (s *Get_conversationContext) ExitRule(listener antlr.ParseTreeListener)

func (*Get_conversationContext) FROM

func (*Get_conversationContext) GET

func (*Get_conversationContext) GROUP

func (*Get_conversationContext) GetConversation_group_id

func (s *Get_conversationContext) GetConversation_group_id() antlr.Token

func (*Get_conversationContext) GetParser

func (s *Get_conversationContext) GetParser() antlr.Parser

func (*Get_conversationContext) GetQueue

func (*Get_conversationContext) GetRuleContext

func (s *Get_conversationContext) GetRuleContext() antlr.RuleContext

func (*Get_conversationContext) IsGet_conversationContext

func (*Get_conversationContext) IsGet_conversationContext()

func (*Get_conversationContext) LOCAL_ID

func (*Get_conversationContext) Queue_id

func (*Get_conversationContext) SEMI

func (*Get_conversationContext) STRING

func (*Get_conversationContext) SetConversation_group_id

func (s *Get_conversationContext) SetConversation_group_id(v antlr.Token)

func (*Get_conversationContext) SetQueue

func (*Get_conversationContext) ToStringTree

func (s *Get_conversationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Go_statementContext

type Go_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyGo_statementContext

func NewEmptyGo_statementContext() *Go_statementContext

func NewGo_statementContext

func NewGo_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Go_statementContext

func (*Go_statementContext) DECIMAL

func (s *Go_statementContext) DECIMAL() antlr.TerminalNode

func (*Go_statementContext) EnterRule

func (s *Go_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Go_statementContext) ExitRule

func (s *Go_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Go_statementContext) GO

func (*Go_statementContext) GetCount

func (s *Go_statementContext) GetCount() antlr.Token

func (*Go_statementContext) GetParser

func (s *Go_statementContext) GetParser() antlr.Parser

func (*Go_statementContext) GetRuleContext

func (s *Go_statementContext) GetRuleContext() antlr.RuleContext

func (*Go_statementContext) IsGo_statementContext

func (*Go_statementContext) IsGo_statementContext()

func (*Go_statementContext) SetCount

func (s *Go_statementContext) SetCount(v antlr.Token)

func (*Go_statementContext) ToStringTree

func (s *Go_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Goto_statementContext

type Goto_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyGoto_statementContext

func NewEmptyGoto_statementContext() *Goto_statementContext

func NewGoto_statementContext

func NewGoto_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Goto_statementContext

func (*Goto_statementContext) COLON

func (*Goto_statementContext) EnterRule

func (s *Goto_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Goto_statementContext) ExitRule

func (s *Goto_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Goto_statementContext) GOTO

func (*Goto_statementContext) GetParser

func (s *Goto_statementContext) GetParser() antlr.Parser

func (*Goto_statementContext) GetRuleContext

func (s *Goto_statementContext) GetRuleContext() antlr.RuleContext

func (*Goto_statementContext) Id

func (*Goto_statementContext) IsGoto_statementContext

func (*Goto_statementContext) IsGoto_statementContext()

func (*Goto_statementContext) SEMI

func (*Goto_statementContext) ToStringTree

func (s *Goto_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Grant_permissionContext

type Grant_permissionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyGrant_permissionContext

func NewEmptyGrant_permissionContext() *Grant_permissionContext

func NewGrant_permissionContext

func NewGrant_permissionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_permissionContext

func (*Grant_permissionContext) ALTER

func (*Grant_permissionContext) ANY

func (*Grant_permissionContext) CONTROL

func (*Grant_permissionContext) CREATE

func (*Grant_permissionContext) DATABASE

func (*Grant_permissionContext) EXECUTE

func (*Grant_permissionContext) EnterRule

func (s *Grant_permissionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Grant_permissionContext) ExitRule

func (s *Grant_permissionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Grant_permissionContext) GetParser

func (s *Grant_permissionContext) GetParser() antlr.Parser

func (*Grant_permissionContext) GetRuleContext

func (s *Grant_permissionContext) GetRuleContext() antlr.RuleContext

func (*Grant_permissionContext) IMPERSONATE

func (s *Grant_permissionContext) IMPERSONATE() antlr.TerminalNode

func (*Grant_permissionContext) INSERT

func (*Grant_permissionContext) Id

func (*Grant_permissionContext) IsGrant_permissionContext

func (*Grant_permissionContext) IsGrant_permissionContext()

func (*Grant_permissionContext) REFERENCES

func (s *Grant_permissionContext) REFERENCES() antlr.TerminalNode

func (*Grant_permissionContext) SELECT

func (*Grant_permissionContext) SHOWPLAN

func (*Grant_permissionContext) TABLE

func (*Grant_permissionContext) TAKE

func (*Grant_permissionContext) ToStringTree

func (s *Grant_permissionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Grant_permissionContext) VIEW

type Group_by_itemContext

type Group_by_itemContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyGroup_by_itemContext

func NewEmptyGroup_by_itemContext() *Group_by_itemContext

func NewGroup_by_itemContext

func NewGroup_by_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_itemContext

func (*Group_by_itemContext) EnterRule

func (s *Group_by_itemContext) EnterRule(listener antlr.ParseTreeListener)

func (*Group_by_itemContext) ExitRule

func (s *Group_by_itemContext) ExitRule(listener antlr.ParseTreeListener)

func (*Group_by_itemContext) Expression

func (s *Group_by_itemContext) Expression() IExpressionContext

func (*Group_by_itemContext) GetParser

func (s *Group_by_itemContext) GetParser() antlr.Parser

func (*Group_by_itemContext) GetRuleContext

func (s *Group_by_itemContext) GetRuleContext() antlr.RuleContext

func (*Group_by_itemContext) IsGroup_by_itemContext

func (*Group_by_itemContext) IsGroup_by_itemContext()

func (*Group_by_itemContext) ToStringTree

func (s *Group_by_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Hadr_optionsContext

type Hadr_optionsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyHadr_optionsContext

func NewEmptyHadr_optionsContext() *Hadr_optionsContext

func NewHadr_optionsContext

func NewHadr_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hadr_optionsContext

func (*Hadr_optionsContext) AVAILABILITY

func (s *Hadr_optionsContext) AVAILABILITY() antlr.TerminalNode

func (*Hadr_optionsContext) EQUAL

func (*Hadr_optionsContext) EnterRule

func (s *Hadr_optionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Hadr_optionsContext) ExitRule

func (s *Hadr_optionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Hadr_optionsContext) GROUP

func (*Hadr_optionsContext) GetAvailability_group_name

func (s *Hadr_optionsContext) GetAvailability_group_name() IIdContext

func (*Hadr_optionsContext) GetParser

func (s *Hadr_optionsContext) GetParser() antlr.Parser

func (*Hadr_optionsContext) GetRuleContext

func (s *Hadr_optionsContext) GetRuleContext() antlr.RuleContext

func (*Hadr_optionsContext) HADR

func (*Hadr_optionsContext) Id

func (*Hadr_optionsContext) IsHadr_optionsContext

func (*Hadr_optionsContext) IsHadr_optionsContext()

func (*Hadr_optionsContext) OFF

func (*Hadr_optionsContext) RESUME

func (*Hadr_optionsContext) SUSPEND

func (s *Hadr_optionsContext) SUSPEND() antlr.TerminalNode

func (*Hadr_optionsContext) SetAvailability_group_name

func (s *Hadr_optionsContext) SetAvailability_group_name(v IIdContext)

func (*Hadr_optionsContext) ToStringTree

func (s *Hadr_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type HostContext

type HostContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyHostContext

func NewEmptyHostContext() *HostContext

func NewHostContext

func NewHostContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HostContext

func (*HostContext) DOT

func (s *HostContext) DOT() antlr.TerminalNode

func (*HostContext) EnterRule

func (s *HostContext) EnterRule(listener antlr.ParseTreeListener)

func (*HostContext) ExitRule

func (s *HostContext) ExitRule(listener antlr.ParseTreeListener)

func (*HostContext) GetParser

func (s *HostContext) GetParser() antlr.Parser

func (*HostContext) GetRuleContext

func (s *HostContext) GetRuleContext() antlr.RuleContext

func (*HostContext) Host

func (s *HostContext) Host() IHostContext

func (*HostContext) Id

func (s *HostContext) Id() IIdContext

func (*HostContext) IsHostContext

func (*HostContext) IsHostContext()

func (*HostContext) ToStringTree

func (s *HostContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IAggregate_windowed_functionContext

type IAggregate_windowed_functionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAggregate_windowed_functionContext differentiates from other interfaces.
	IsAggregate_windowed_functionContext()
}

IAggregate_windowed_functionContext is an interface to support dynamic dispatch.

type IAlgorithmContext

type IAlgorithmContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlgorithmContext differentiates from other interfaces.
	IsAlgorithmContext()
}

IAlgorithmContext is an interface to support dynamic dispatch.

type IAll_distinct_expressionContext

type IAll_distinct_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAll_distinct_expressionContext differentiates from other interfaces.
	IsAll_distinct_expressionContext()
}

IAll_distinct_expressionContext is an interface to support dynamic dispatch.

type IAlter_application_roleContext

type IAlter_application_roleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetApplication_role_password returns the application_role_password token.
	GetApplication_role_password() antlr.Token

	// SetApplication_role_password sets the application_role_password token.
	SetApplication_role_password(antlr.Token)

	// GetAppliction_role returns the appliction_role rule contexts.
	GetAppliction_role() IIdContext

	// GetNew_application_role_name returns the new_application_role_name rule contexts.
	GetNew_application_role_name() IIdContext

	// GetApp_role_default_schema returns the app_role_default_schema rule contexts.
	GetApp_role_default_schema() IIdContext

	// SetAppliction_role sets the appliction_role rule contexts.
	SetAppliction_role(IIdContext)

	// SetNew_application_role_name sets the new_application_role_name rule contexts.
	SetNew_application_role_name(IIdContext)

	// SetApp_role_default_schema sets the app_role_default_schema rule contexts.
	SetApp_role_default_schema(IIdContext)

	// IsAlter_application_roleContext differentiates from other interfaces.
	IsAlter_application_roleContext()
}

IAlter_application_roleContext is an interface to support dynamic dispatch.

type IAlter_assemblyContext

type IAlter_assemblyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAssembly_name returns the assembly_name rule contexts.
	GetAssembly_name() IIdContext

	// SetAssembly_name sets the assembly_name rule contexts.
	SetAssembly_name(IIdContext)

	// IsAlter_assemblyContext differentiates from other interfaces.
	IsAlter_assemblyContext()
}

IAlter_assemblyContext is an interface to support dynamic dispatch.

type IAlter_assembly_add_clauseContext

type IAlter_assembly_add_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_add_clauseContext differentiates from other interfaces.
	IsAlter_assembly_add_clauseContext()
}

IAlter_assembly_add_clauseContext is an interface to support dynamic dispatch.

type IAlter_assembly_asContext

type IAlter_assembly_asContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_asContext differentiates from other interfaces.
	IsAlter_assembly_asContext()
}

IAlter_assembly_asContext is an interface to support dynamic dispatch.

type IAlter_assembly_clauseContext

type IAlter_assembly_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_clauseContext differentiates from other interfaces.
	IsAlter_assembly_clauseContext()
}

IAlter_assembly_clauseContext is an interface to support dynamic dispatch.

type IAlter_assembly_client_file_clauseContext

type IAlter_assembly_client_file_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_client_file_clauseContext differentiates from other interfaces.
	IsAlter_assembly_client_file_clauseContext()
}

IAlter_assembly_client_file_clauseContext is an interface to support dynamic dispatch.

type IAlter_assembly_dropContext

type IAlter_assembly_dropContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_dropContext differentiates from other interfaces.
	IsAlter_assembly_dropContext()
}

IAlter_assembly_dropContext is an interface to support dynamic dispatch.

type IAlter_assembly_drop_clauseContext

type IAlter_assembly_drop_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_drop_clauseContext differentiates from other interfaces.
	IsAlter_assembly_drop_clauseContext()
}

IAlter_assembly_drop_clauseContext is an interface to support dynamic dispatch.

type IAlter_assembly_drop_multiple_filesContext

type IAlter_assembly_drop_multiple_filesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_drop_multiple_filesContext differentiates from other interfaces.
	IsAlter_assembly_drop_multiple_filesContext()
}

IAlter_assembly_drop_multiple_filesContext is an interface to support dynamic dispatch.

type IAlter_assembly_file_bitsContext

type IAlter_assembly_file_bitsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_file_bitsContext differentiates from other interfaces.
	IsAlter_assembly_file_bitsContext()
}

IAlter_assembly_file_bitsContext is an interface to support dynamic dispatch.

type IAlter_assembly_file_nameContext

type IAlter_assembly_file_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_file_nameContext differentiates from other interfaces.
	IsAlter_assembly_file_nameContext()
}

IAlter_assembly_file_nameContext is an interface to support dynamic dispatch.

type IAlter_assembly_from_clauseContext

type IAlter_assembly_from_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_from_clauseContext differentiates from other interfaces.
	IsAlter_assembly_from_clauseContext()
}

IAlter_assembly_from_clauseContext is an interface to support dynamic dispatch.

type IAlter_assembly_from_clause_startContext

type IAlter_assembly_from_clause_startContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_from_clause_startContext differentiates from other interfaces.
	IsAlter_assembly_from_clause_startContext()
}

IAlter_assembly_from_clause_startContext is an interface to support dynamic dispatch.

type IAlter_assembly_startContext

type IAlter_assembly_startContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_startContext differentiates from other interfaces.
	IsAlter_assembly_startContext()
}

IAlter_assembly_startContext is an interface to support dynamic dispatch.

type IAlter_assembly_withContext

type IAlter_assembly_withContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_withContext differentiates from other interfaces.
	IsAlter_assembly_withContext()
}

IAlter_assembly_withContext is an interface to support dynamic dispatch.

type IAlter_assembly_with_clauseContext

type IAlter_assembly_with_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_assembly_with_clauseContext differentiates from other interfaces.
	IsAlter_assembly_with_clauseContext()
}

IAlter_assembly_with_clauseContext is an interface to support dynamic dispatch.

type IAlter_asssembly_add_clause_startContext

type IAlter_asssembly_add_clause_startContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_asssembly_add_clause_startContext differentiates from other interfaces.
	IsAlter_asssembly_add_clause_startContext()
}

IAlter_asssembly_add_clause_startContext is an interface to support dynamic dispatch.

type IAlter_asymmetric_keyContext

type IAlter_asymmetric_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAsym_Key_Name returns the Asym_Key_Name rule contexts.
	GetAsym_Key_Name() IIdContext

	// SetAsym_Key_Name sets the Asym_Key_Name rule contexts.
	SetAsym_Key_Name(IIdContext)

	// IsAlter_asymmetric_keyContext differentiates from other interfaces.
	IsAlter_asymmetric_keyContext()
}

IAlter_asymmetric_keyContext is an interface to support dynamic dispatch.

type IAlter_asymmetric_key_startContext

type IAlter_asymmetric_key_startContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_asymmetric_key_startContext differentiates from other interfaces.
	IsAlter_asymmetric_key_startContext()
}

IAlter_asymmetric_key_startContext is an interface to support dynamic dispatch.

type IAlter_authorizationContext

type IAlter_authorizationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetEntity returns the entity rule contexts.
	GetEntity() IEntity_nameContext

	// SetEntity sets the entity rule contexts.
	SetEntity(IEntity_nameContext)

	// IsAlter_authorizationContext differentiates from other interfaces.
	IsAlter_authorizationContext()
}

IAlter_authorizationContext is an interface to support dynamic dispatch.

type IAlter_authorization_for_azure_dwContext

type IAlter_authorization_for_azure_dwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetEntity returns the entity rule contexts.
	GetEntity() IEntity_name_for_azure_dwContext

	// SetEntity sets the entity rule contexts.
	SetEntity(IEntity_name_for_azure_dwContext)

	// IsAlter_authorization_for_azure_dwContext differentiates from other interfaces.
	IsAlter_authorization_for_azure_dwContext()
}

IAlter_authorization_for_azure_dwContext is an interface to support dynamic dispatch.

type IAlter_authorization_for_parallel_dwContext

type IAlter_authorization_for_parallel_dwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetEntity returns the entity rule contexts.
	GetEntity() IEntity_name_for_parallel_dwContext

	// SetEntity sets the entity rule contexts.
	SetEntity(IEntity_name_for_parallel_dwContext)

	// IsAlter_authorization_for_parallel_dwContext differentiates from other interfaces.
	IsAlter_authorization_for_parallel_dwContext()
}

IAlter_authorization_for_parallel_dwContext is an interface to support dynamic dispatch.

type IAlter_authorization_for_sql_databaseContext

type IAlter_authorization_for_sql_databaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetEntity returns the entity rule contexts.
	GetEntity() IEntity_nameContext

	// SetEntity sets the entity rule contexts.
	SetEntity(IEntity_nameContext)

	// IsAlter_authorization_for_sql_databaseContext differentiates from other interfaces.
	IsAlter_authorization_for_sql_databaseContext()
}

IAlter_authorization_for_sql_databaseContext is an interface to support dynamic dispatch.

type IAlter_authorization_startContext

type IAlter_authorization_startContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_authorization_startContext differentiates from other interfaces.
	IsAlter_authorization_startContext()
}

IAlter_authorization_startContext is an interface to support dynamic dispatch.

type IAlter_availability_groupContext

type IAlter_availability_groupContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_availability_groupContext differentiates from other interfaces.
	IsAlter_availability_groupContext()
}

IAlter_availability_groupContext is an interface to support dynamic dispatch.

type IAlter_availability_group_optionsContext

type IAlter_availability_group_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMilliseconds returns the milliseconds token.
	GetMilliseconds() antlr.Token

	// GetServer_instance returns the server_instance token.
	GetServer_instance() antlr.Token

	// GetSession_timeout returns the session_timeout token.
	GetSession_timeout() antlr.Token

	// GetAg_name returns the ag_name token.
	GetAg_name() antlr.Token

	// GetAg_name_modified returns the ag_name_modified token.
	GetAg_name_modified() antlr.Token

	// GetListener_name returns the listener_name token.
	GetListener_name() antlr.Token

	// SetMilliseconds sets the milliseconds token.
	SetMilliseconds(antlr.Token)

	// SetServer_instance sets the server_instance token.
	SetServer_instance(antlr.Token)

	// SetSession_timeout sets the session_timeout token.
	SetSession_timeout(antlr.Token)

	// SetAg_name sets the ag_name token.
	SetAg_name(antlr.Token)

	// SetAg_name_modified sets the ag_name_modified token.
	SetAg_name_modified(antlr.Token)

	// SetListener_name sets the listener_name token.
	SetListener_name(antlr.Token)

	// GetDatabase_name returns the database_name rule contexts.
	GetDatabase_name() IIdContext

	// SetDatabase_name sets the database_name rule contexts.
	SetDatabase_name(IIdContext)

	// IsAlter_availability_group_optionsContext differentiates from other interfaces.
	IsAlter_availability_group_optionsContext()
}

IAlter_availability_group_optionsContext is an interface to support dynamic dispatch.

type IAlter_availability_group_startContext

type IAlter_availability_group_startContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetGroup_name returns the group_name rule contexts.
	GetGroup_name() IIdContext

	// SetGroup_name sets the group_name rule contexts.
	SetGroup_name(IIdContext)

	// IsAlter_availability_group_startContext differentiates from other interfaces.
	IsAlter_availability_group_startContext()
}

IAlter_availability_group_startContext is an interface to support dynamic dispatch.

type IAlter_certificateContext

type IAlter_certificateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCertificate_name returns the certificate_name rule contexts.
	GetCertificate_name() IIdContext

	// SetCertificate_name sets the certificate_name rule contexts.
	SetCertificate_name(IIdContext)

	// IsAlter_certificateContext differentiates from other interfaces.
	IsAlter_certificateContext()
}

IAlter_certificateContext is an interface to support dynamic dispatch.

type IAlter_column_encryption_keyContext

type IAlter_column_encryption_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAlgorithm_name returns the algorithm_name token.
	GetAlgorithm_name() antlr.Token

	// SetAlgorithm_name sets the algorithm_name token.
	SetAlgorithm_name(antlr.Token)

	// GetColumn_encryption_key returns the column_encryption_key rule contexts.
	GetColumn_encryption_key() IIdContext

	// GetColumn_master_key_name returns the column_master_key_name rule contexts.
	GetColumn_master_key_name() IIdContext

	// SetColumn_encryption_key sets the column_encryption_key rule contexts.
	SetColumn_encryption_key(IIdContext)

	// SetColumn_master_key_name sets the column_master_key_name rule contexts.
	SetColumn_master_key_name(IIdContext)

	// IsAlter_column_encryption_keyContext differentiates from other interfaces.
	IsAlter_column_encryption_keyContext()
}

IAlter_column_encryption_keyContext is an interface to support dynamic dispatch.

type IAlter_credentialContext

type IAlter_credentialContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetIdentity_name returns the identity_name token.
	GetIdentity_name() antlr.Token

	// GetSecret returns the secret token.
	GetSecret() antlr.Token

	// SetIdentity_name sets the identity_name token.
	SetIdentity_name(antlr.Token)

	// SetSecret sets the secret token.
	SetSecret(antlr.Token)

	// GetCredential_name returns the credential_name rule contexts.
	GetCredential_name() IIdContext

	// SetCredential_name sets the credential_name rule contexts.
	SetCredential_name(IIdContext)

	// IsAlter_credentialContext differentiates from other interfaces.
	IsAlter_credentialContext()
}

IAlter_credentialContext is an interface to support dynamic dispatch.

type IAlter_cryptographic_providerContext

type IAlter_cryptographic_providerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCrypto_provider_ddl_file returns the crypto_provider_ddl_file token.
	GetCrypto_provider_ddl_file() antlr.Token

	// SetCrypto_provider_ddl_file sets the crypto_provider_ddl_file token.
	SetCrypto_provider_ddl_file(antlr.Token)

	// GetProvider_name returns the provider_name rule contexts.
	GetProvider_name() IIdContext

	// SetProvider_name sets the provider_name rule contexts.
	SetProvider_name(IIdContext)

	// IsAlter_cryptographic_providerContext differentiates from other interfaces.
	IsAlter_cryptographic_providerContext()
}

IAlter_cryptographic_providerContext is an interface to support dynamic dispatch.

type IAlter_databaseContext

type IAlter_databaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDatabase returns the database rule contexts.
	GetDatabase() IIdContext

	// GetNew_name returns the new_name rule contexts.
	GetNew_name() IIdContext

	// GetCollation returns the collation rule contexts.
	GetCollation() IIdContext

	// SetDatabase sets the database rule contexts.
	SetDatabase(IIdContext)

	// SetNew_name sets the new_name rule contexts.
	SetNew_name(IIdContext)

	// SetCollation sets the collation rule contexts.
	SetCollation(IIdContext)

	// IsAlter_databaseContext differentiates from other interfaces.
	IsAlter_databaseContext()
}

IAlter_databaseContext is an interface to support dynamic dispatch.

type IAlter_db_roleContext

type IAlter_db_roleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRole_name returns the role_name rule contexts.
	GetRole_name() IIdContext

	// GetDatabase_principal returns the database_principal rule contexts.
	GetDatabase_principal() IIdContext

	// GetNew_role_name returns the new_role_name rule contexts.
	GetNew_role_name() IIdContext

	// SetRole_name sets the role_name rule contexts.
	SetRole_name(IIdContext)

	// SetDatabase_principal sets the database_principal rule contexts.
	SetDatabase_principal(IIdContext)

	// SetNew_role_name sets the new_role_name rule contexts.
	SetNew_role_name(IIdContext)

	// IsAlter_db_roleContext differentiates from other interfaces.
	IsAlter_db_roleContext()
}

IAlter_db_roleContext is an interface to support dynamic dispatch.

type IAlter_endpointContext

type IAlter_endpointContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetState returns the state token.
	GetState() antlr.Token

	// GetPort returns the port token.
	GetPort() antlr.Token

	// SetState sets the state token.
	SetState(antlr.Token)

	// SetPort sets the port token.
	SetPort(antlr.Token)

	// GetEndpointname returns the endpointname rule contexts.
	GetEndpointname() IIdContext

	// GetLogin returns the login rule contexts.
	GetLogin() IIdContext

	// GetCert_name returns the cert_name rule contexts.
	GetCert_name() IIdContext

	// SetEndpointname sets the endpointname rule contexts.
	SetEndpointname(IIdContext)

	// SetLogin sets the login rule contexts.
	SetLogin(IIdContext)

	// SetCert_name sets the cert_name rule contexts.
	SetCert_name(IIdContext)

	// IsAlter_endpointContext differentiates from other interfaces.
	IsAlter_endpointContext()
}

IAlter_endpointContext is an interface to support dynamic dispatch.

type IAlter_external_data_sourceContext

type IAlter_external_data_sourceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetLocation returns the location token.
	GetLocation() antlr.Token

	// GetResource_manager_location returns the resource_manager_location token.
	GetResource_manager_location() antlr.Token

	// SetLocation sets the location token.
	SetLocation(antlr.Token)

	// SetResource_manager_location sets the resource_manager_location token.
	SetResource_manager_location(antlr.Token)

	// GetData_source_name returns the data_source_name rule contexts.
	GetData_source_name() IIdContext

	// GetCredential_name returns the credential_name rule contexts.
	GetCredential_name() IIdContext

	// SetData_source_name sets the data_source_name rule contexts.
	SetData_source_name(IIdContext)

	// SetCredential_name sets the credential_name rule contexts.
	SetCredential_name(IIdContext)

	// IsAlter_external_data_sourceContext differentiates from other interfaces.
	IsAlter_external_data_sourceContext()
}

IAlter_external_data_sourceContext is an interface to support dynamic dispatch.

type IAlter_external_libraryContext

type IAlter_external_libraryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetClient_library returns the client_library token.
	GetClient_library() antlr.Token

	// SetClient_library sets the client_library token.
	SetClient_library(antlr.Token)

	// GetLibrary_name returns the library_name rule contexts.
	GetLibrary_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// GetExternal_data_source_name returns the external_data_source_name rule contexts.
	GetExternal_data_source_name() IIdContext

	// SetLibrary_name sets the library_name rule contexts.
	SetLibrary_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// SetExternal_data_source_name sets the external_data_source_name rule contexts.
	SetExternal_data_source_name(IIdContext)

	// IsAlter_external_libraryContext differentiates from other interfaces.
	IsAlter_external_libraryContext()
}

IAlter_external_libraryContext is an interface to support dynamic dispatch.

type IAlter_external_resource_poolContext

type IAlter_external_resource_poolContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMax_cpu_percent returns the max_cpu_percent token.
	GetMax_cpu_percent() antlr.Token

	// GetMax_memory_percent returns the max_memory_percent token.
	GetMax_memory_percent() antlr.Token

	// GetMax_processes returns the max_processes token.
	GetMax_processes() antlr.Token

	// SetMax_cpu_percent sets the max_cpu_percent token.
	SetMax_cpu_percent(antlr.Token)

	// SetMax_memory_percent sets the max_memory_percent token.
	SetMax_memory_percent(antlr.Token)

	// SetMax_processes sets the max_processes token.
	SetMax_processes(antlr.Token)

	// GetPool_name returns the pool_name rule contexts.
	GetPool_name() IIdContext

	// SetPool_name sets the pool_name rule contexts.
	SetPool_name(IIdContext)

	// IsAlter_external_resource_poolContext differentiates from other interfaces.
	IsAlter_external_resource_poolContext()
}

IAlter_external_resource_poolContext is an interface to support dynamic dispatch.

type IAlter_fulltext_catalogContext

type IAlter_fulltext_catalogContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCatalog_name returns the catalog_name rule contexts.
	GetCatalog_name() IIdContext

	// SetCatalog_name sets the catalog_name rule contexts.
	SetCatalog_name(IIdContext)

	// IsAlter_fulltext_catalogContext differentiates from other interfaces.
	IsAlter_fulltext_catalogContext()
}

IAlter_fulltext_catalogContext is an interface to support dynamic dispatch.

type IAlter_fulltext_stoplistContext

type IAlter_fulltext_stoplistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetStopword returns the stopword token.
	GetStopword() antlr.Token

	// SetStopword sets the stopword token.
	SetStopword(antlr.Token)

	// GetStoplist_name returns the stoplist_name rule contexts.
	GetStoplist_name() IIdContext

	// SetStoplist_name sets the stoplist_name rule contexts.
	SetStoplist_name(IIdContext)

	// IsAlter_fulltext_stoplistContext differentiates from other interfaces.
	IsAlter_fulltext_stoplistContext()
}

IAlter_fulltext_stoplistContext is an interface to support dynamic dispatch.

type IAlter_login_azure_sqlContext

type IAlter_login_azure_sqlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// GetOld_password returns the old_password token.
	GetOld_password() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// SetOld_password sets the old_password token.
	SetOld_password(antlr.Token)

	// GetLogin_name returns the login_name rule contexts.
	GetLogin_name() IIdContext

	// SetLogin_name sets the login_name rule contexts.
	SetLogin_name(IIdContext)

	// IsAlter_login_azure_sqlContext differentiates from other interfaces.
	IsAlter_login_azure_sqlContext()
}

IAlter_login_azure_sqlContext is an interface to support dynamic dispatch.

type IAlter_login_azure_sql_dw_and_pdwContext

type IAlter_login_azure_sql_dw_and_pdwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// GetOld_password returns the old_password token.
	GetOld_password() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// SetOld_password sets the old_password token.
	SetOld_password(antlr.Token)

	// GetLogin_name returns the login_name rule contexts.
	GetLogin_name() IIdContext

	// SetLogin_name sets the login_name rule contexts.
	SetLogin_name(IIdContext)

	// IsAlter_login_azure_sql_dw_and_pdwContext differentiates from other interfaces.
	IsAlter_login_azure_sql_dw_and_pdwContext()
}

IAlter_login_azure_sql_dw_and_pdwContext is an interface to support dynamic dispatch.

type IAlter_login_sql_serverContext

type IAlter_login_sql_serverContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// GetPassword_hash returns the password_hash token.
	GetPassword_hash() antlr.Token

	// GetOld_password returns the old_password token.
	GetOld_password() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// SetPassword_hash sets the password_hash token.
	SetPassword_hash(antlr.Token)

	// SetOld_password sets the old_password token.
	SetOld_password(antlr.Token)

	// GetLogin_name returns the login_name rule contexts.
	GetLogin_name() IIdContext

	// GetDefault_database returns the default_database rule contexts.
	GetDefault_database() IIdContext

	// GetDefault_laguage returns the default_laguage rule contexts.
	GetDefault_laguage() IIdContext

	// GetCredential_name returns the credential_name rule contexts.
	GetCredential_name() IIdContext

	// SetLogin_name sets the login_name rule contexts.
	SetLogin_name(IIdContext)

	// SetDefault_database sets the default_database rule contexts.
	SetDefault_database(IIdContext)

	// SetDefault_laguage sets the default_laguage rule contexts.
	SetDefault_laguage(IIdContext)

	// SetCredential_name sets the credential_name rule contexts.
	SetCredential_name(IIdContext)

	// IsAlter_login_sql_serverContext differentiates from other interfaces.
	IsAlter_login_sql_serverContext()
}

IAlter_login_sql_serverContext is an interface to support dynamic dispatch.

type IAlter_master_key_azure_sqlContext

type IAlter_master_key_azure_sqlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// GetEncryption_password returns the encryption_password token.
	GetEncryption_password() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// SetEncryption_password sets the encryption_password token.
	SetEncryption_password(antlr.Token)

	// IsAlter_master_key_azure_sqlContext differentiates from other interfaces.
	IsAlter_master_key_azure_sqlContext()
}

IAlter_master_key_azure_sqlContext is an interface to support dynamic dispatch.

type IAlter_master_key_sql_serverContext

type IAlter_master_key_sql_serverContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// GetEncryption_password returns the encryption_password token.
	GetEncryption_password() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// SetEncryption_password sets the encryption_password token.
	SetEncryption_password(antlr.Token)

	// IsAlter_master_key_sql_serverContext differentiates from other interfaces.
	IsAlter_master_key_sql_serverContext()
}

IAlter_master_key_sql_serverContext is an interface to support dynamic dispatch.

type IAlter_message_typeContext

type IAlter_message_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMessage_type_name returns the message_type_name rule contexts.
	GetMessage_type_name() IIdContext

	// GetSchema_collection_name returns the schema_collection_name rule contexts.
	GetSchema_collection_name() IIdContext

	// SetMessage_type_name sets the message_type_name rule contexts.
	SetMessage_type_name(IIdContext)

	// SetSchema_collection_name sets the schema_collection_name rule contexts.
	SetSchema_collection_name(IIdContext)

	// IsAlter_message_typeContext differentiates from other interfaces.
	IsAlter_message_typeContext()
}

IAlter_message_typeContext is an interface to support dynamic dispatch.

type IAlter_partition_functionContext

type IAlter_partition_functionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPartition_function_name returns the partition_function_name rule contexts.
	GetPartition_function_name() IIdContext

	// SetPartition_function_name sets the partition_function_name rule contexts.
	SetPartition_function_name(IIdContext)

	// IsAlter_partition_functionContext differentiates from other interfaces.
	IsAlter_partition_functionContext()
}

IAlter_partition_functionContext is an interface to support dynamic dispatch.

type IAlter_partition_schemeContext

type IAlter_partition_schemeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPartition_scheme_name returns the partition_scheme_name rule contexts.
	GetPartition_scheme_name() IIdContext

	// GetFile_group_name returns the file_group_name rule contexts.
	GetFile_group_name() IIdContext

	// SetPartition_scheme_name sets the partition_scheme_name rule contexts.
	SetPartition_scheme_name(IIdContext)

	// SetFile_group_name sets the file_group_name rule contexts.
	SetFile_group_name(IIdContext)

	// IsAlter_partition_schemeContext differentiates from other interfaces.
	IsAlter_partition_schemeContext()
}

IAlter_partition_schemeContext is an interface to support dynamic dispatch.

type IAlter_queueContext

type IAlter_queueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetQueue_name returns the queue_name rule contexts.
	GetQueue_name() IIdContext

	// SetQueue_name sets the queue_name rule contexts.
	SetQueue_name(IIdContext)

	// IsAlter_queueContext differentiates from other interfaces.
	IsAlter_queueContext()
}

IAlter_queueContext is an interface to support dynamic dispatch.

type IAlter_remote_service_bindingContext

type IAlter_remote_service_bindingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetBinding_name returns the binding_name rule contexts.
	GetBinding_name() IIdContext

	// GetUser_name returns the user_name rule contexts.
	GetUser_name() IIdContext

	// SetBinding_name sets the binding_name rule contexts.
	SetBinding_name(IIdContext)

	// SetUser_name sets the user_name rule contexts.
	SetUser_name(IIdContext)

	// IsAlter_remote_service_bindingContext differentiates from other interfaces.
	IsAlter_remote_service_bindingContext()
}

IAlter_remote_service_bindingContext is an interface to support dynamic dispatch.

type IAlter_resource_governorContext

type IAlter_resource_governorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMax_outstanding_io_per_volume returns the max_outstanding_io_per_volume token.
	GetMax_outstanding_io_per_volume() antlr.Token

	// SetMax_outstanding_io_per_volume sets the max_outstanding_io_per_volume token.
	SetMax_outstanding_io_per_volume(antlr.Token)

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetFunction_name returns the function_name rule contexts.
	GetFunction_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetFunction_name sets the function_name rule contexts.
	SetFunction_name(IIdContext)

	// IsAlter_resource_governorContext differentiates from other interfaces.
	IsAlter_resource_governorContext()
}

IAlter_resource_governorContext is an interface to support dynamic dispatch.

type IAlter_schema_azure_sql_dw_and_pdwContext

type IAlter_schema_azure_sql_dw_and_pdwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// IsAlter_schema_azure_sql_dw_and_pdwContext differentiates from other interfaces.
	IsAlter_schema_azure_sql_dw_and_pdwContext()
}

IAlter_schema_azure_sql_dw_and_pdwContext is an interface to support dynamic dispatch.

type IAlter_schema_sqlContext

type IAlter_schema_sqlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// IsAlter_schema_sqlContext differentiates from other interfaces.
	IsAlter_schema_sqlContext()
}

IAlter_schema_sqlContext is an interface to support dynamic dispatch.

type IAlter_sequenceContext

type IAlter_sequenceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSequnce_increment returns the sequnce_increment token.
	GetSequnce_increment() antlr.Token

	// SetSequnce_increment sets the sequnce_increment token.
	SetSequnce_increment(antlr.Token)

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetSequence_name returns the sequence_name rule contexts.
	GetSequence_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetSequence_name sets the sequence_name rule contexts.
	SetSequence_name(IIdContext)

	// IsAlter_sequenceContext differentiates from other interfaces.
	IsAlter_sequenceContext()
}

IAlter_sequenceContext is an interface to support dynamic dispatch.

type IAlter_server_auditContext

type IAlter_server_auditContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetFilepath returns the filepath token.
	GetFilepath() antlr.Token

	// GetMax_rollover_files returns the max_rollover_files token.
	GetMax_rollover_files() antlr.Token

	// GetMax_files returns the max_files token.
	GetMax_files() antlr.Token

	// GetQueue_delay returns the queue_delay token.
	GetQueue_delay() antlr.Token

	// SetFilepath sets the filepath token.
	SetFilepath(antlr.Token)

	// SetMax_rollover_files sets the max_rollover_files token.
	SetMax_rollover_files(antlr.Token)

	// SetMax_files sets the max_files token.
	SetMax_files(antlr.Token)

	// SetQueue_delay sets the queue_delay token.
	SetQueue_delay(antlr.Token)

	// GetAudit_name returns the audit_name rule contexts.
	GetAudit_name() IIdContext

	// GetEvent_field_name returns the event_field_name rule contexts.
	GetEvent_field_name() IIdContext

	// GetNew_audit_name returns the new_audit_name rule contexts.
	GetNew_audit_name() IIdContext

	// SetAudit_name sets the audit_name rule contexts.
	SetAudit_name(IIdContext)

	// SetEvent_field_name sets the event_field_name rule contexts.
	SetEvent_field_name(IIdContext)

	// SetNew_audit_name sets the new_audit_name rule contexts.
	SetNew_audit_name(IIdContext)

	// IsAlter_server_auditContext differentiates from other interfaces.
	IsAlter_server_auditContext()
}

IAlter_server_auditContext is an interface to support dynamic dispatch.

type IAlter_server_audit_specificationContext

type IAlter_server_audit_specificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAudit_specification_name returns the audit_specification_name rule contexts.
	GetAudit_specification_name() IIdContext

	// GetAudit_name returns the audit_name rule contexts.
	GetAudit_name() IIdContext

	// GetAudit_action_group_name returns the audit_action_group_name rule contexts.
	GetAudit_action_group_name() IIdContext

	// SetAudit_specification_name sets the audit_specification_name rule contexts.
	SetAudit_specification_name(IIdContext)

	// SetAudit_name sets the audit_name rule contexts.
	SetAudit_name(IIdContext)

	// SetAudit_action_group_name sets the audit_action_group_name rule contexts.
	SetAudit_action_group_name(IIdContext)

	// IsAlter_server_audit_specificationContext differentiates from other interfaces.
	IsAlter_server_audit_specificationContext()
}

IAlter_server_audit_specificationContext is an interface to support dynamic dispatch.

type IAlter_server_configurationContext

type IAlter_server_configurationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAlter_server_configurationContext differentiates from other interfaces.
	IsAlter_server_configurationContext()
}

IAlter_server_configurationContext is an interface to support dynamic dispatch.

type IAlter_server_roleContext

type IAlter_server_roleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetServer_role_name returns the server_role_name rule contexts.
	GetServer_role_name() IIdContext

	// GetServer_principal returns the server_principal rule contexts.
	GetServer_principal() IIdContext

	// GetNew_server_role_name returns the new_server_role_name rule contexts.
	GetNew_server_role_name() IIdContext

	// SetServer_role_name sets the server_role_name rule contexts.
	SetServer_role_name(IIdContext)

	// SetServer_principal sets the server_principal rule contexts.
	SetServer_principal(IIdContext)

	// SetNew_server_role_name sets the new_server_role_name rule contexts.
	SetNew_server_role_name(IIdContext)

	// IsAlter_server_roleContext differentiates from other interfaces.
	IsAlter_server_roleContext()
}

IAlter_server_roleContext is an interface to support dynamic dispatch.

type IAlter_server_role_pdwContext

type IAlter_server_role_pdwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetServer_role_name returns the server_role_name rule contexts.
	GetServer_role_name() IIdContext

	// GetLogin returns the login rule contexts.
	GetLogin() IIdContext

	// SetServer_role_name sets the server_role_name rule contexts.
	SetServer_role_name(IIdContext)

	// SetLogin sets the login rule contexts.
	SetLogin(IIdContext)

	// IsAlter_server_role_pdwContext differentiates from other interfaces.
	IsAlter_server_role_pdwContext()
}

IAlter_server_role_pdwContext is an interface to support dynamic dispatch.

type IAlter_serviceContext

type IAlter_serviceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetModified_service_name returns the modified_service_name rule contexts.
	GetModified_service_name() IIdContext

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetQueue_name returns the queue_name rule contexts.
	GetQueue_name() IIdContext

	// GetModified_contract_name returns the modified_contract_name rule contexts.
	GetModified_contract_name() IIdContext

	// SetModified_service_name sets the modified_service_name rule contexts.
	SetModified_service_name(IIdContext)

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetQueue_name sets the queue_name rule contexts.
	SetQueue_name(IIdContext)

	// SetModified_contract_name sets the modified_contract_name rule contexts.
	SetModified_contract_name(IIdContext)

	// IsAlter_serviceContext differentiates from other interfaces.
	IsAlter_serviceContext()
}

IAlter_serviceContext is an interface to support dynamic dispatch.

type IAlter_service_master_keyContext

type IAlter_service_master_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAcold_account_name returns the acold_account_name token.
	GetAcold_account_name() antlr.Token

	// GetOld_password returns the old_password token.
	GetOld_password() antlr.Token

	// GetNew_account_name returns the new_account_name token.
	GetNew_account_name() antlr.Token

	// GetNew_password returns the new_password token.
	GetNew_password() antlr.Token

	// SetAcold_account_name sets the acold_account_name token.
	SetAcold_account_name(antlr.Token)

	// SetOld_password sets the old_password token.
	SetOld_password(antlr.Token)

	// SetNew_account_name sets the new_account_name token.
	SetNew_account_name(antlr.Token)

	// SetNew_password sets the new_password token.
	SetNew_password(antlr.Token)

	// IsAlter_service_master_keyContext differentiates from other interfaces.
	IsAlter_service_master_keyContext()
}

IAlter_service_master_keyContext is an interface to support dynamic dispatch.

type IAlter_symmetric_keyContext

type IAlter_symmetric_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// GetKey_name returns the key_name rule contexts.
	GetKey_name() IIdContext

	// GetCertificate_name returns the certificate_name rule contexts.
	GetCertificate_name() IIdContext

	// GetSymmetric_key_name returns the symmetric_key_name rule contexts.
	GetSymmetric_key_name() IIdContext

	// GetAsym_key_name returns the Asym_key_name rule contexts.
	GetAsym_key_name() IIdContext

	// SetKey_name sets the key_name rule contexts.
	SetKey_name(IIdContext)

	// SetCertificate_name sets the certificate_name rule contexts.
	SetCertificate_name(IIdContext)

	// SetSymmetric_key_name sets the symmetric_key_name rule contexts.
	SetSymmetric_key_name(IIdContext)

	// SetAsym_key_name sets the Asym_key_name rule contexts.
	SetAsym_key_name(IIdContext)

	// IsAlter_symmetric_keyContext differentiates from other interfaces.
	IsAlter_symmetric_keyContext()
}

IAlter_symmetric_keyContext is an interface to support dynamic dispatch.

type IAlter_tableContext

type IAlter_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetConstraint returns the constraint rule contexts.
	GetConstraint() IIdContext

	// GetFk returns the fk rule contexts.
	GetFk() IColumn_name_listContext

	// GetPk returns the pk rule contexts.
	GetPk() IColumn_name_listContext

	// SetConstraint sets the constraint rule contexts.
	SetConstraint(IIdContext)

	// SetFk sets the fk rule contexts.
	SetFk(IColumn_name_listContext)

	// SetPk sets the pk rule contexts.
	SetPk(IColumn_name_listContext)

	// IsAlter_tableContext differentiates from other interfaces.
	IsAlter_tableContext()
}

IAlter_tableContext is an interface to support dynamic dispatch.

type IAlter_userContext

type IAlter_userContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetLcid returns the lcid token.
	GetLcid() antlr.Token

	// SetLcid sets the lcid token.
	SetLcid(antlr.Token)

	// GetUsername returns the username rule contexts.
	GetUsername() IIdContext

	// GetNewusername returns the newusername rule contexts.
	GetNewusername() IIdContext

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetLoginame returns the loginame rule contexts.
	GetLoginame() IIdContext

	// GetLanguage_name_or_alias returns the language_name_or_alias rule contexts.
	GetLanguage_name_or_alias() IIdContext

	// SetUsername sets the username rule contexts.
	SetUsername(IIdContext)

	// SetNewusername sets the newusername rule contexts.
	SetNewusername(IIdContext)

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetLoginame sets the loginame rule contexts.
	SetLoginame(IIdContext)

	// SetLanguage_name_or_alias sets the language_name_or_alias rule contexts.
	SetLanguage_name_or_alias(IIdContext)

	// IsAlter_userContext differentiates from other interfaces.
	IsAlter_userContext()
}

IAlter_userContext is an interface to support dynamic dispatch.

type IAlter_user_azure_sqlContext

type IAlter_user_azure_sqlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetUsername returns the username rule contexts.
	GetUsername() IIdContext

	// GetNewusername returns the newusername rule contexts.
	GetNewusername() IIdContext

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetLoginame returns the loginame rule contexts.
	GetLoginame() IIdContext

	// SetUsername sets the username rule contexts.
	SetUsername(IIdContext)

	// SetNewusername sets the newusername rule contexts.
	SetNewusername(IIdContext)

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetLoginame sets the loginame rule contexts.
	SetLoginame(IIdContext)

	// IsAlter_user_azure_sqlContext differentiates from other interfaces.
	IsAlter_user_azure_sqlContext()
}

IAlter_user_azure_sqlContext is an interface to support dynamic dispatch.

type IAlter_workload_groupContext

type IAlter_workload_groupContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRequest_max_memory_grant returns the request_max_memory_grant token.
	GetRequest_max_memory_grant() antlr.Token

	// GetRequest_max_cpu_time_sec returns the request_max_cpu_time_sec token.
	GetRequest_max_cpu_time_sec() antlr.Token

	// GetRequest_memory_grant_timeout_sec returns the request_memory_grant_timeout_sec token.
	GetRequest_memory_grant_timeout_sec() antlr.Token

	// GetMax_dop returns the max_dop token.
	GetMax_dop() antlr.Token

	// GetGroup_max_requests returns the group_max_requests token.
	GetGroup_max_requests() antlr.Token

	// SetRequest_max_memory_grant sets the request_max_memory_grant token.
	SetRequest_max_memory_grant(antlr.Token)

	// SetRequest_max_cpu_time_sec sets the request_max_cpu_time_sec token.
	SetRequest_max_cpu_time_sec(antlr.Token)

	// SetRequest_memory_grant_timeout_sec sets the request_memory_grant_timeout_sec token.
	SetRequest_memory_grant_timeout_sec(antlr.Token)

	// SetMax_dop sets the max_dop token.
	SetMax_dop(antlr.Token)

	// SetGroup_max_requests sets the group_max_requests token.
	SetGroup_max_requests(antlr.Token)

	// GetWorkload_group_group_name returns the workload_group_group_name rule contexts.
	GetWorkload_group_group_name() IIdContext

	// GetWorkload_group_pool_name returns the workload_group_pool_name rule contexts.
	GetWorkload_group_pool_name() IIdContext

	// SetWorkload_group_group_name sets the workload_group_group_name rule contexts.
	SetWorkload_group_group_name(IIdContext)

	// SetWorkload_group_pool_name sets the workload_group_pool_name rule contexts.
	SetWorkload_group_pool_name(IIdContext)

	// IsAlter_workload_groupContext differentiates from other interfaces.
	IsAlter_workload_groupContext()
}

IAlter_workload_groupContext is an interface to support dynamic dispatch.

type IAnalytic_windowed_functionContext

type IAnalytic_windowed_functionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAnalytic_windowed_functionContext differentiates from other interfaces.
	IsAnalytic_windowed_functionContext()
}

IAnalytic_windowed_functionContext is an interface to support dynamic dispatch.

type IAnother_statementContext

type IAnother_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAnother_statementContext differentiates from other interfaces.
	IsAnother_statementContext()
}

IAnother_statementContext is an interface to support dynamic dispatch.

type IAs_column_aliasContext

type IAs_column_aliasContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAs_column_aliasContext differentiates from other interfaces.
	IsAs_column_aliasContext()
}

IAs_column_aliasContext is an interface to support dynamic dispatch.

type IAs_table_aliasContext

type IAs_table_aliasContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAs_table_aliasContext differentiates from other interfaces.
	IsAs_table_aliasContext()
}

IAs_table_aliasContext is an interface to support dynamic dispatch.

type IAssembly_optionContext

type IAssembly_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssembly_optionContext differentiates from other interfaces.
	IsAssembly_optionContext()
}

IAssembly_optionContext is an interface to support dynamic dispatch.

type IAssignment_operatorContext

type IAssignment_operatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAssignment_operatorContext differentiates from other interfaces.
	IsAssignment_operatorContext()
}

IAssignment_operatorContext is an interface to support dynamic dispatch.

type IAsteriskContext

type IAsteriskContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAsteriskContext differentiates from other interfaces.
	IsAsteriskContext()
}

IAsteriskContext is an interface to support dynamic dispatch.

type IAsymmetric_key_optionContext

type IAsymmetric_key_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAsymmetric_key_optionContext differentiates from other interfaces.
	IsAsymmetric_key_optionContext()
}

IAsymmetric_key_optionContext is an interface to support dynamic dispatch.

type IAsymmetric_key_option_startContext

type IAsymmetric_key_option_startContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAsymmetric_key_option_startContext differentiates from other interfaces.
	IsAsymmetric_key_option_startContext()
}

IAsymmetric_key_option_startContext is an interface to support dynamic dispatch.

type IAsymmetric_key_password_change_optionContext

type IAsymmetric_key_password_change_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAsymmetric_key_password_change_optionContext differentiates from other interfaces.
	IsAsymmetric_key_password_change_optionContext()
}

IAsymmetric_key_password_change_optionContext is an interface to support dynamic dispatch.

type IAuthorization_granteeContext

type IAuthorization_granteeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPrincipal_name returns the principal_name rule contexts.
	GetPrincipal_name() IIdContext

	// SetPrincipal_name sets the principal_name rule contexts.
	SetPrincipal_name(IIdContext)

	// IsAuthorization_granteeContext differentiates from other interfaces.
	IsAuthorization_granteeContext()
}

IAuthorization_granteeContext is an interface to support dynamic dispatch.

type IAuto_optionContext

type IAuto_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAuto_optionContext differentiates from other interfaces.
	IsAuto_optionContext()
}

IAuto_optionContext is an interface to support dynamic dispatch.

type IBackup_certificateContext

type IBackup_certificateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCert_file returns the cert_file token.
	GetCert_file() antlr.Token

	// GetPrivate_key_file returns the private_key_file token.
	GetPrivate_key_file() antlr.Token

	// GetEncryption_password returns the encryption_password token.
	GetEncryption_password() antlr.Token

	// GetDecryption_pasword returns the decryption_pasword token.
	GetDecryption_pasword() antlr.Token

	// SetCert_file sets the cert_file token.
	SetCert_file(antlr.Token)

	// SetPrivate_key_file sets the private_key_file token.
	SetPrivate_key_file(antlr.Token)

	// SetEncryption_password sets the encryption_password token.
	SetEncryption_password(antlr.Token)

	// SetDecryption_pasword sets the decryption_pasword token.
	SetDecryption_pasword(antlr.Token)

	// GetCertname returns the certname rule contexts.
	GetCertname() IIdContext

	// SetCertname sets the certname rule contexts.
	SetCertname(IIdContext)

	// IsBackup_certificateContext differentiates from other interfaces.
	IsBackup_certificateContext()
}

IBackup_certificateContext is an interface to support dynamic dispatch.

type IBackup_databaseContext

type IBackup_databaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetFile_or_filegroup returns the file_or_filegroup token.
	GetFile_or_filegroup() antlr.Token

	// GetMedianame returns the medianame token.
	GetMedianame() antlr.Token

	// GetStats_percent returns the stats_percent token.
	GetStats_percent() antlr.Token

	// SetFile_or_filegroup sets the file_or_filegroup token.
	SetFile_or_filegroup(antlr.Token)

	// SetMedianame sets the medianame token.
	SetMedianame(antlr.Token)

	// SetStats_percent sets the stats_percent token.
	SetStats_percent(antlr.Token)

	// GetDatabase_name returns the database_name rule contexts.
	GetDatabase_name() IIdContext

	// GetLogical_device_name returns the logical_device_name rule contexts.
	GetLogical_device_name() IIdContext

	// GetBackup_set_name returns the backup_set_name rule contexts.
	GetBackup_set_name() IIdContext

	// GetEncryptor_name returns the encryptor_name rule contexts.
	GetEncryptor_name() IIdContext

	// SetDatabase_name sets the database_name rule contexts.
	SetDatabase_name(IIdContext)

	// SetLogical_device_name sets the logical_device_name rule contexts.
	SetLogical_device_name(IIdContext)

	// SetBackup_set_name sets the backup_set_name rule contexts.
	SetBackup_set_name(IIdContext)

	// SetEncryptor_name sets the encryptor_name rule contexts.
	SetEncryptor_name(IIdContext)

	// IsBackup_databaseContext differentiates from other interfaces.
	IsBackup_databaseContext()
}

IBackup_databaseContext is an interface to support dynamic dispatch.

type IBackup_logContext

type IBackup_logContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMedianame returns the medianame token.
	GetMedianame() antlr.Token

	// GetStats_percent returns the stats_percent token.
	GetStats_percent() antlr.Token

	// GetUndo_file_name returns the undo_file_name token.
	GetUndo_file_name() antlr.Token

	// SetMedianame sets the medianame token.
	SetMedianame(antlr.Token)

	// SetStats_percent sets the stats_percent token.
	SetStats_percent(antlr.Token)

	// SetUndo_file_name sets the undo_file_name token.
	SetUndo_file_name(antlr.Token)

	// GetDatabase_name returns the database_name rule contexts.
	GetDatabase_name() IIdContext

	// GetLogical_device_name returns the logical_device_name rule contexts.
	GetLogical_device_name() IIdContext

	// GetBackup_set_name returns the backup_set_name rule contexts.
	GetBackup_set_name() IIdContext

	// GetEncryptor_name returns the encryptor_name rule contexts.
	GetEncryptor_name() IIdContext

	// SetDatabase_name sets the database_name rule contexts.
	SetDatabase_name(IIdContext)

	// SetLogical_device_name sets the logical_device_name rule contexts.
	SetLogical_device_name(IIdContext)

	// SetBackup_set_name sets the backup_set_name rule contexts.
	SetBackup_set_name(IIdContext)

	// SetEncryptor_name sets the encryptor_name rule contexts.
	SetEncryptor_name(IIdContext)

	// IsBackup_logContext differentiates from other interfaces.
	IsBackup_logContext()
}

IBackup_logContext is an interface to support dynamic dispatch.

type IBackup_master_keyContext

type IBackup_master_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMaster_key_backup_file returns the master_key_backup_file token.
	GetMaster_key_backup_file() antlr.Token

	// GetEncryption_password returns the encryption_password token.
	GetEncryption_password() antlr.Token

	// SetMaster_key_backup_file sets the master_key_backup_file token.
	SetMaster_key_backup_file(antlr.Token)

	// SetEncryption_password sets the encryption_password token.
	SetEncryption_password(antlr.Token)

	// IsBackup_master_keyContext differentiates from other interfaces.
	IsBackup_master_keyContext()
}

IBackup_master_keyContext is an interface to support dynamic dispatch.

type IBackup_service_master_keyContext

type IBackup_service_master_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetService_master_key_backup_file returns the service_master_key_backup_file token.
	GetService_master_key_backup_file() antlr.Token

	// GetEncryption_password returns the encryption_password token.
	GetEncryption_password() antlr.Token

	// SetService_master_key_backup_file sets the service_master_key_backup_file token.
	SetService_master_key_backup_file(antlr.Token)

	// SetEncryption_password sets the encryption_password token.
	SetEncryption_password(antlr.Token)

	// IsBackup_service_master_keyContext differentiates from other interfaces.
	IsBackup_service_master_keyContext()
}

IBackup_service_master_keyContext is an interface to support dynamic dispatch.

type IBackup_statementContext

type IBackup_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBackup_statementContext differentiates from other interfaces.
	IsBackup_statementContext()
}

IBackup_statementContext is an interface to support dynamic dispatch.

type IBatchContext

type IBatchContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBatchContext differentiates from other interfaces.
	IsBatchContext()
}

IBatchContext is an interface to support dynamic dispatch.

type IBegin_conversation_dialogContext

type IBegin_conversation_dialogContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDialog_handle returns the dialog_handle token.
	GetDialog_handle() antlr.Token

	// GetService_broker_guid returns the service_broker_guid token.
	GetService_broker_guid() antlr.Token

	// SetDialog_handle sets the dialog_handle token.
	SetDialog_handle(antlr.Token)

	// SetService_broker_guid sets the service_broker_guid token.
	SetService_broker_guid(antlr.Token)

	// GetInitiator_service_name returns the initiator_service_name rule contexts.
	GetInitiator_service_name() IService_nameContext

	// GetTarget_service_name returns the target_service_name rule contexts.
	GetTarget_service_name() IService_nameContext

	// SetInitiator_service_name sets the initiator_service_name rule contexts.
	SetInitiator_service_name(IService_nameContext)

	// SetTarget_service_name sets the target_service_name rule contexts.
	SetTarget_service_name(IService_nameContext)

	// IsBegin_conversation_dialogContext differentiates from other interfaces.
	IsBegin_conversation_dialogContext()
}

IBegin_conversation_dialogContext is an interface to support dynamic dispatch.

type IBegin_conversation_timerContext

type IBegin_conversation_timerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBegin_conversation_timerContext differentiates from other interfaces.
	IsBegin_conversation_timerContext()
}

IBegin_conversation_timerContext is an interface to support dynamic dispatch.

type IBlock_statementContext

type IBlock_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBlock_statementContext differentiates from other interfaces.
	IsBlock_statementContext()
}

IBlock_statementContext is an interface to support dynamic dispatch.

type IBracket_expressionContext

type IBracket_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBracket_expressionContext differentiates from other interfaces.
	IsBracket_expressionContext()
}

IBracket_expressionContext is an interface to support dynamic dispatch.

type IBreak_statementContext

type IBreak_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBreak_statementContext differentiates from other interfaces.
	IsBreak_statementContext()
}

IBreak_statementContext is an interface to support dynamic dispatch.

type IBulk_optionContext

type IBulk_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetBulk_option_value returns the bulk_option_value token.
	GetBulk_option_value() antlr.Token

	// SetBulk_option_value sets the bulk_option_value token.
	SetBulk_option_value(antlr.Token)

	// IsBulk_optionContext differentiates from other interfaces.
	IsBulk_optionContext()
}

IBulk_optionContext is an interface to support dynamic dispatch.

type ICase_expressionContext

type ICase_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCaseExpr returns the caseExpr rule contexts.
	GetCaseExpr() IExpressionContext

	// GetElseExpr returns the elseExpr rule contexts.
	GetElseExpr() IExpressionContext

	// SetCaseExpr sets the caseExpr rule contexts.
	SetCaseExpr(IExpressionContext)

	// SetElseExpr sets the elseExpr rule contexts.
	SetElseExpr(IExpressionContext)

	// IsCase_expressionContext differentiates from other interfaces.
	IsCase_expressionContext()
}

ICase_expressionContext is an interface to support dynamic dispatch.

type ICfl_statementContext

type ICfl_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCfl_statementContext differentiates from other interfaces.
	IsCfl_statementContext()
}

ICfl_statementContext is an interface to support dynamic dispatch.

type IChange_tableContext

type IChange_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsChange_tableContext differentiates from other interfaces.
	IsChange_tableContext()
}

IChange_tableContext is an interface to support dynamic dispatch.

type IChange_tracking_optionContext

type IChange_tracking_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsChange_tracking_optionContext differentiates from other interfaces.
	IsChange_tracking_optionContext()
}

IChange_tracking_optionContext is an interface to support dynamic dispatch.

type IChange_tracking_option_listContext

type IChange_tracking_option_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsChange_tracking_option_listContext differentiates from other interfaces.
	IsChange_tracking_option_listContext()
}

IChange_tracking_option_listContext is an interface to support dynamic dispatch.

type IClass_typeContext

type IClass_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClass_typeContext differentiates from other interfaces.
	IsClass_typeContext()
}

IClass_typeContext is an interface to support dynamic dispatch.

type IClass_type_for_azure_dwContext

type IClass_type_for_azure_dwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClass_type_for_azure_dwContext differentiates from other interfaces.
	IsClass_type_for_azure_dwContext()
}

IClass_type_for_azure_dwContext is an interface to support dynamic dispatch.

type IClass_type_for_parallel_dwContext

type IClass_type_for_parallel_dwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClass_type_for_parallel_dwContext differentiates from other interfaces.
	IsClass_type_for_parallel_dwContext()
}

IClass_type_for_parallel_dwContext is an interface to support dynamic dispatch.

type IClass_type_for_sql_databaseContext

type IClass_type_for_sql_databaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClass_type_for_sql_databaseContext differentiates from other interfaces.
	IsClass_type_for_sql_databaseContext()
}

IClass_type_for_sql_databaseContext is an interface to support dynamic dispatch.

type IClient_assembly_specifierContext

type IClient_assembly_specifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClient_assembly_specifierContext differentiates from other interfaces.
	IsClient_assembly_specifierContext()
}

IClient_assembly_specifierContext is an interface to support dynamic dispatch.

type IClose_keyContext

type IClose_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetKey_name returns the key_name rule contexts.
	GetKey_name() IIdContext

	// SetKey_name sets the key_name rule contexts.
	SetKey_name(IIdContext)

	// IsClose_keyContext differentiates from other interfaces.
	IsClose_keyContext()
}

IClose_keyContext is an interface to support dynamic dispatch.

type IClusteredContext

type IClusteredContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsClusteredContext differentiates from other interfaces.
	IsClusteredContext()
}

IClusteredContext is an interface to support dynamic dispatch.

type IColon_colonContext

type IColon_colonContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColon_colonContext differentiates from other interfaces.
	IsColon_colonContext()
}

IColon_colonContext is an interface to support dynamic dispatch.

type IColumn_aliasContext

type IColumn_aliasContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumn_aliasContext differentiates from other interfaces.
	IsColumn_aliasContext()
}

IColumn_aliasContext is an interface to support dynamic dispatch.

type IColumn_alias_listContext

type IColumn_alias_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumn_alias_listContext differentiates from other interfaces.
	IsColumn_alias_listContext()
}

IColumn_alias_listContext is an interface to support dynamic dispatch.

type IColumn_constraintContext

type IColumn_constraintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetConstraint returns the constraint rule contexts.
	GetConstraint() IIdContext

	// GetPk returns the pk rule contexts.
	GetPk() IColumn_name_listContext

	// SetConstraint sets the constraint rule contexts.
	SetConstraint(IIdContext)

	// SetPk sets the pk rule contexts.
	SetPk(IColumn_name_listContext)

	// IsColumn_constraintContext differentiates from other interfaces.
	IsColumn_constraintContext()
}

IColumn_constraintContext is an interface to support dynamic dispatch.

type IColumn_declarationContext

type IColumn_declarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumn_declarationContext differentiates from other interfaces.
	IsColumn_declarationContext()
}

IColumn_declarationContext is an interface to support dynamic dispatch.

type IColumn_def_table_constraintContext

type IColumn_def_table_constraintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumn_def_table_constraintContext differentiates from other interfaces.
	IsColumn_def_table_constraintContext()
}

IColumn_def_table_constraintContext is an interface to support dynamic dispatch.

type IColumn_def_table_constraintsContext

type IColumn_def_table_constraintsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumn_def_table_constraintsContext differentiates from other interfaces.
	IsColumn_def_table_constraintsContext()
}

IColumn_def_table_constraintsContext is an interface to support dynamic dispatch.

type IColumn_definitionContext

type IColumn_definitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSeed returns the seed token.
	GetSeed() antlr.Token

	// GetIncrement returns the increment token.
	GetIncrement() antlr.Token

	// SetSeed sets the seed token.
	SetSeed(antlr.Token)

	// SetIncrement sets the increment token.
	SetIncrement(antlr.Token)

	// GetConstraint returns the constraint rule contexts.
	GetConstraint() IIdContext

	// SetConstraint sets the constraint rule contexts.
	SetConstraint(IIdContext)

	// IsColumn_definitionContext differentiates from other interfaces.
	IsColumn_definitionContext()
}

IColumn_definitionContext is an interface to support dynamic dispatch.

type IColumn_elemContext

type IColumn_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetColumn_name returns the column_name rule contexts.
	GetColumn_name() IIdContext

	// SetColumn_name sets the column_name rule contexts.
	SetColumn_name(IIdContext)

	// IsColumn_elemContext differentiates from other interfaces.
	IsColumn_elemContext()
}

IColumn_elemContext is an interface to support dynamic dispatch.

type IColumn_name_listContext

type IColumn_name_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumn_name_listContext differentiates from other interfaces.
	IsColumn_name_listContext()
}

IColumn_name_listContext is an interface to support dynamic dispatch.

type IColumn_name_list_with_orderContext

type IColumn_name_list_with_orderContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsColumn_name_list_with_orderContext differentiates from other interfaces.
	IsColumn_name_list_with_orderContext()
}

IColumn_name_list_with_orderContext is an interface to support dynamic dispatch.

type ICommon_table_expressionContext

type ICommon_table_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetExpression_name returns the expression_name rule contexts.
	GetExpression_name() IIdContext

	// SetExpression_name sets the expression_name rule contexts.
	SetExpression_name(IIdContext)

	// IsCommon_table_expressionContext differentiates from other interfaces.
	IsCommon_table_expressionContext()
}

ICommon_table_expressionContext is an interface to support dynamic dispatch.

type IComparison_operatorContext

type IComparison_operatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsComparison_operatorContext differentiates from other interfaces.
	IsComparison_operatorContext()
}

IComparison_operatorContext is an interface to support dynamic dispatch.

type IConstantContext

type IConstantContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDollar returns the dollar token.
	GetDollar() antlr.Token

	// SetDollar sets the dollar token.
	SetDollar(antlr.Token)

	// IsConstantContext differentiates from other interfaces.
	IsConstantContext()
}

IConstantContext is an interface to support dynamic dispatch.

type IConstant_LOCAL_IDContext

type IConstant_LOCAL_IDContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstant_LOCAL_IDContext differentiates from other interfaces.
	IsConstant_LOCAL_IDContext()
}

IConstant_LOCAL_IDContext is an interface to support dynamic dispatch.

type IConstant_expressionContext

type IConstant_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConstant_expressionContext differentiates from other interfaces.
	IsConstant_expressionContext()
}

IConstant_expressionContext is an interface to support dynamic dispatch.

type IContainment_optionContext

type IContainment_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsContainment_optionContext differentiates from other interfaces.
	IsContainment_optionContext()
}

IContainment_optionContext is an interface to support dynamic dispatch.

type IContinue_statementContext

type IContinue_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsContinue_statementContext differentiates from other interfaces.
	IsContinue_statementContext()
}

IContinue_statementContext is an interface to support dynamic dispatch.

type IContract_nameContext

type IContract_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsContract_nameContext differentiates from other interfaces.
	IsContract_nameContext()
}

IContract_nameContext is an interface to support dynamic dispatch.

type IConversation_statementContext

type IConversation_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsConversation_statementContext differentiates from other interfaces.
	IsConversation_statementContext()
}

IConversation_statementContext is an interface to support dynamic dispatch.

type ICreate_application_roleContext

type ICreate_application_roleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetApplication_role_password returns the application_role_password token.
	GetApplication_role_password() antlr.Token

	// SetApplication_role_password sets the application_role_password token.
	SetApplication_role_password(antlr.Token)

	// GetAppliction_role returns the appliction_role rule contexts.
	GetAppliction_role() IIdContext

	// GetApp_role_default_schema returns the app_role_default_schema rule contexts.
	GetApp_role_default_schema() IIdContext

	// SetAppliction_role sets the appliction_role rule contexts.
	SetAppliction_role(IIdContext)

	// SetApp_role_default_schema sets the app_role_default_schema rule contexts.
	SetApp_role_default_schema(IIdContext)

	// IsCreate_application_roleContext differentiates from other interfaces.
	IsCreate_application_roleContext()
}

ICreate_application_roleContext is an interface to support dynamic dispatch.

type ICreate_assemblyContext

type ICreate_assemblyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAssembly_name returns the assembly_name rule contexts.
	GetAssembly_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// SetAssembly_name sets the assembly_name rule contexts.
	SetAssembly_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// IsCreate_assemblyContext differentiates from other interfaces.
	IsCreate_assemblyContext()
}

ICreate_assemblyContext is an interface to support dynamic dispatch.

type ICreate_asymmetric_keyContext

type ICreate_asymmetric_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetProvider_key_name returns the provider_key_name token.
	GetProvider_key_name() antlr.Token

	// GetAsymmetric_key_password returns the asymmetric_key_password token.
	GetAsymmetric_key_password() antlr.Token

	// SetProvider_key_name sets the provider_key_name token.
	SetProvider_key_name(antlr.Token)

	// SetAsymmetric_key_password sets the asymmetric_key_password token.
	SetAsymmetric_key_password(antlr.Token)

	// GetAsym_Key_Nam returns the Asym_Key_Nam rule contexts.
	GetAsym_Key_Nam() IIdContext

	// GetDatabase_principal_name returns the database_principal_name rule contexts.
	GetDatabase_principal_name() IIdContext

	// GetAssembly_Name returns the Assembly_Name rule contexts.
	GetAssembly_Name() IIdContext

	// GetProvider_Name returns the Provider_Name rule contexts.
	GetProvider_Name() IIdContext

	// SetAsym_Key_Nam sets the Asym_Key_Nam rule contexts.
	SetAsym_Key_Nam(IIdContext)

	// SetDatabase_principal_name sets the database_principal_name rule contexts.
	SetDatabase_principal_name(IIdContext)

	// SetAssembly_Name sets the Assembly_Name rule contexts.
	SetAssembly_Name(IIdContext)

	// SetProvider_Name sets the Provider_Name rule contexts.
	SetProvider_Name(IIdContext)

	// IsCreate_asymmetric_keyContext differentiates from other interfaces.
	IsCreate_asymmetric_keyContext()
}

ICreate_asymmetric_keyContext is an interface to support dynamic dispatch.

type ICreate_certificateContext

type ICreate_certificateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCertificate_name returns the certificate_name rule contexts.
	GetCertificate_name() IIdContext

	// GetUser_name returns the user_name rule contexts.
	GetUser_name() IIdContext

	// SetCertificate_name sets the certificate_name rule contexts.
	SetCertificate_name(IIdContext)

	// SetUser_name sets the user_name rule contexts.
	SetUser_name(IIdContext)

	// IsCreate_certificateContext differentiates from other interfaces.
	IsCreate_certificateContext()
}

ICreate_certificateContext is an interface to support dynamic dispatch.

type ICreate_column_encryption_keyContext

type ICreate_column_encryption_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAlgorithm_name returns the algorithm_name token.
	GetAlgorithm_name() antlr.Token

	// GetEncrypted_value returns the encrypted_value token.
	GetEncrypted_value() antlr.Token

	// SetAlgorithm_name sets the algorithm_name token.
	SetAlgorithm_name(antlr.Token)

	// SetEncrypted_value sets the encrypted_value token.
	SetEncrypted_value(antlr.Token)

	// GetColumn_encryption_key returns the column_encryption_key rule contexts.
	GetColumn_encryption_key() IIdContext

	// GetColumn_master_key_name returns the column_master_key_name rule contexts.
	GetColumn_master_key_name() IIdContext

	// SetColumn_encryption_key sets the column_encryption_key rule contexts.
	SetColumn_encryption_key(IIdContext)

	// SetColumn_master_key_name sets the column_master_key_name rule contexts.
	SetColumn_master_key_name(IIdContext)

	// IsCreate_column_encryption_keyContext differentiates from other interfaces.
	IsCreate_column_encryption_keyContext()
}

ICreate_column_encryption_keyContext is an interface to support dynamic dispatch.

type ICreate_column_master_keyContext

type ICreate_column_master_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetKey_store_provider_name returns the key_store_provider_name token.
	GetKey_store_provider_name() antlr.Token

	// GetKey_path returns the key_path token.
	GetKey_path() antlr.Token

	// SetKey_store_provider_name sets the key_store_provider_name token.
	SetKey_store_provider_name(antlr.Token)

	// SetKey_path sets the key_path token.
	SetKey_path(antlr.Token)

	// GetKey_name returns the key_name rule contexts.
	GetKey_name() IIdContext

	// SetKey_name sets the key_name rule contexts.
	SetKey_name(IIdContext)

	// IsCreate_column_master_keyContext differentiates from other interfaces.
	IsCreate_column_master_keyContext()
}

ICreate_column_master_keyContext is an interface to support dynamic dispatch.

type ICreate_contractContext

type ICreate_contractContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// GetMessage_type_name returns the message_type_name rule contexts.
	GetMessage_type_name() IIdContext

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// SetMessage_type_name sets the message_type_name rule contexts.
	SetMessage_type_name(IIdContext)

	// IsCreate_contractContext differentiates from other interfaces.
	IsCreate_contractContext()
}

ICreate_contractContext is an interface to support dynamic dispatch.

type ICreate_credentialContext

type ICreate_credentialContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetIdentity_name returns the identity_name token.
	GetIdentity_name() antlr.Token

	// GetSecret returns the secret token.
	GetSecret() antlr.Token

	// SetIdentity_name sets the identity_name token.
	SetIdentity_name(antlr.Token)

	// SetSecret sets the secret token.
	SetSecret(antlr.Token)

	// GetCredential_name returns the credential_name rule contexts.
	GetCredential_name() IIdContext

	// GetCryptographic_provider_name returns the cryptographic_provider_name rule contexts.
	GetCryptographic_provider_name() IIdContext

	// SetCredential_name sets the credential_name rule contexts.
	SetCredential_name(IIdContext)

	// SetCryptographic_provider_name sets the cryptographic_provider_name rule contexts.
	SetCryptographic_provider_name(IIdContext)

	// IsCreate_credentialContext differentiates from other interfaces.
	IsCreate_credentialContext()
}

ICreate_credentialContext is an interface to support dynamic dispatch.

type ICreate_cryptographic_providerContext

type ICreate_cryptographic_providerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPath_of_DLL returns the path_of_DLL token.
	GetPath_of_DLL() antlr.Token

	// SetPath_of_DLL sets the path_of_DLL token.
	SetPath_of_DLL(antlr.Token)

	// GetProvider_name returns the provider_name rule contexts.
	GetProvider_name() IIdContext

	// SetProvider_name sets the provider_name rule contexts.
	SetProvider_name(IIdContext)

	// IsCreate_cryptographic_providerContext differentiates from other interfaces.
	IsCreate_cryptographic_providerContext()
}

ICreate_cryptographic_providerContext is an interface to support dynamic dispatch.

type ICreate_databaseContext

type ICreate_databaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDatabase returns the database rule contexts.
	GetDatabase() IIdContext

	// GetCollation_name returns the collation_name rule contexts.
	GetCollation_name() IIdContext

	// SetDatabase sets the database rule contexts.
	SetDatabase(IIdContext)

	// SetCollation_name sets the collation_name rule contexts.
	SetCollation_name(IIdContext)

	// IsCreate_databaseContext differentiates from other interfaces.
	IsCreate_databaseContext()
}

ICreate_databaseContext is an interface to support dynamic dispatch.

type ICreate_database_optionContext

type ICreate_database_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCreate_database_optionContext differentiates from other interfaces.
	IsCreate_database_optionContext()
}

ICreate_database_optionContext is an interface to support dynamic dispatch.

type ICreate_db_roleContext

type ICreate_db_roleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRole_name returns the role_name rule contexts.
	GetRole_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// SetRole_name sets the role_name rule contexts.
	SetRole_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// IsCreate_db_roleContext differentiates from other interfaces.
	IsCreate_db_roleContext()
}

ICreate_db_roleContext is an interface to support dynamic dispatch.

type ICreate_event_notificationContext

type ICreate_event_notificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetBroker_service returns the broker_service token.
	GetBroker_service() antlr.Token

	// GetBroker_service_specifier_or_current_database returns the broker_service_specifier_or_current_database token.
	GetBroker_service_specifier_or_current_database() antlr.Token

	// SetBroker_service sets the broker_service token.
	SetBroker_service(antlr.Token)

	// SetBroker_service_specifier_or_current_database sets the broker_service_specifier_or_current_database token.
	SetBroker_service_specifier_or_current_database(antlr.Token)

	// GetEvent_notification_name returns the event_notification_name rule contexts.
	GetEvent_notification_name() IIdContext

	// GetQueue_name returns the queue_name rule contexts.
	GetQueue_name() IIdContext

	// GetEvent_type_or_group returns the event_type_or_group rule contexts.
	GetEvent_type_or_group() IIdContext

	// SetEvent_notification_name sets the event_notification_name rule contexts.
	SetEvent_notification_name(IIdContext)

	// SetQueue_name sets the queue_name rule contexts.
	SetQueue_name(IIdContext)

	// SetEvent_type_or_group sets the event_type_or_group rule contexts.
	SetEvent_type_or_group(IIdContext)

	// IsCreate_event_notificationContext differentiates from other interfaces.
	IsCreate_event_notificationContext()
}

ICreate_event_notificationContext is an interface to support dynamic dispatch.

type ICreate_external_libraryContext

type ICreate_external_libraryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetClient_library returns the client_library token.
	GetClient_library() antlr.Token

	// SetClient_library sets the client_library token.
	SetClient_library(antlr.Token)

	// GetLibrary_name returns the library_name rule contexts.
	GetLibrary_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// GetExternal_data_source_name returns the external_data_source_name rule contexts.
	GetExternal_data_source_name() IIdContext

	// SetLibrary_name sets the library_name rule contexts.
	SetLibrary_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// SetExternal_data_source_name sets the external_data_source_name rule contexts.
	SetExternal_data_source_name(IIdContext)

	// IsCreate_external_libraryContext differentiates from other interfaces.
	IsCreate_external_libraryContext()
}

ICreate_external_libraryContext is an interface to support dynamic dispatch.

type ICreate_external_resource_poolContext

type ICreate_external_resource_poolContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMax_cpu_percent returns the max_cpu_percent token.
	GetMax_cpu_percent() antlr.Token

	// GetMax_memory_percent returns the max_memory_percent token.
	GetMax_memory_percent() antlr.Token

	// GetMax_processes returns the max_processes token.
	GetMax_processes() antlr.Token

	// SetMax_cpu_percent sets the max_cpu_percent token.
	SetMax_cpu_percent(antlr.Token)

	// SetMax_memory_percent sets the max_memory_percent token.
	SetMax_memory_percent(antlr.Token)

	// SetMax_processes sets the max_processes token.
	SetMax_processes(antlr.Token)

	// GetPool_name returns the pool_name rule contexts.
	GetPool_name() IIdContext

	// SetPool_name sets the pool_name rule contexts.
	SetPool_name(IIdContext)

	// IsCreate_external_resource_poolContext differentiates from other interfaces.
	IsCreate_external_resource_poolContext()
}

ICreate_external_resource_poolContext is an interface to support dynamic dispatch.

type ICreate_fulltext_catalogContext

type ICreate_fulltext_catalogContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRootpath returns the rootpath token.
	GetRootpath() antlr.Token

	// SetRootpath sets the rootpath token.
	SetRootpath(antlr.Token)

	// GetCatalog_name returns the catalog_name rule contexts.
	GetCatalog_name() IIdContext

	// GetFilegroup returns the filegroup rule contexts.
	GetFilegroup() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// SetCatalog_name sets the catalog_name rule contexts.
	SetCatalog_name(IIdContext)

	// SetFilegroup sets the filegroup rule contexts.
	SetFilegroup(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// IsCreate_fulltext_catalogContext differentiates from other interfaces.
	IsCreate_fulltext_catalogContext()
}

ICreate_fulltext_catalogContext is an interface to support dynamic dispatch.

type ICreate_fulltext_stoplistContext

type ICreate_fulltext_stoplistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetStoplist_name returns the stoplist_name rule contexts.
	GetStoplist_name() IIdContext

	// GetDatabase_name returns the database_name rule contexts.
	GetDatabase_name() IIdContext

	// GetSource_stoplist_name returns the source_stoplist_name rule contexts.
	GetSource_stoplist_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// SetStoplist_name sets the stoplist_name rule contexts.
	SetStoplist_name(IIdContext)

	// SetDatabase_name sets the database_name rule contexts.
	SetDatabase_name(IIdContext)

	// SetSource_stoplist_name sets the source_stoplist_name rule contexts.
	SetSource_stoplist_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// IsCreate_fulltext_stoplistContext differentiates from other interfaces.
	IsCreate_fulltext_stoplistContext()
}

ICreate_fulltext_stoplistContext is an interface to support dynamic dispatch.

type ICreate_indexContext

type ICreate_indexContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetWhere returns the where rule contexts.
	GetWhere() ISearch_conditionContext

	// SetWhere sets the where rule contexts.
	SetWhere(ISearch_conditionContext)

	// IsCreate_indexContext differentiates from other interfaces.
	IsCreate_indexContext()
}

ICreate_indexContext is an interface to support dynamic dispatch.

type ICreate_keyContext

type ICreate_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// GetKey_name returns the key_name rule contexts.
	GetKey_name() IIdContext

	// GetUser_name returns the user_name rule contexts.
	GetUser_name() IIdContext

	// GetProvider_name returns the provider_name rule contexts.
	GetProvider_name() IIdContext

	// SetKey_name sets the key_name rule contexts.
	SetKey_name(IIdContext)

	// SetUser_name sets the user_name rule contexts.
	SetUser_name(IIdContext)

	// SetProvider_name sets the provider_name rule contexts.
	SetProvider_name(IIdContext)

	// IsCreate_keyContext differentiates from other interfaces.
	IsCreate_keyContext()
}

ICreate_keyContext is an interface to support dynamic dispatch.

type ICreate_login_azure_sqlContext

type ICreate_login_azure_sqlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSid returns the sid token.
	GetSid() antlr.Token

	// SetSid sets the sid token.
	SetSid(antlr.Token)

	// GetLogin_name returns the login_name rule contexts.
	GetLogin_name() IIdContext

	// SetLogin_name sets the login_name rule contexts.
	SetLogin_name(IIdContext)

	// IsCreate_login_azure_sqlContext differentiates from other interfaces.
	IsCreate_login_azure_sqlContext()
}

ICreate_login_azure_sqlContext is an interface to support dynamic dispatch.

type ICreate_login_pdwContext

type ICreate_login_pdwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// GetLoginName returns the loginName rule contexts.
	GetLoginName() IIdContext

	// SetLoginName sets the loginName rule contexts.
	SetLoginName(IIdContext)

	// IsCreate_login_pdwContext differentiates from other interfaces.
	IsCreate_login_pdwContext()
}

ICreate_login_pdwContext is an interface to support dynamic dispatch.

type ICreate_login_sql_serverContext

type ICreate_login_sql_serverContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// GetPassword_hash returns the password_hash token.
	GetPassword_hash() antlr.Token

	// GetSid returns the sid token.
	GetSid() antlr.Token

	// GetDefault_language returns the default_language token.
	GetDefault_language() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// SetPassword_hash sets the password_hash token.
	SetPassword_hash(antlr.Token)

	// SetSid sets the sid token.
	SetSid(antlr.Token)

	// SetDefault_language sets the default_language token.
	SetDefault_language(antlr.Token)

	// GetLogin_name returns the login_name rule contexts.
	GetLogin_name() IIdContext

	// GetDefault_database returns the default_database rule contexts.
	GetDefault_database() IIdContext

	// GetDefault_laguage returns the default_laguage rule contexts.
	GetDefault_laguage() IIdContext

	// GetCredential_name returns the credential_name rule contexts.
	GetCredential_name() IIdContext

	// GetCertname returns the certname rule contexts.
	GetCertname() IIdContext

	// GetAsym_key_name returns the asym_key_name rule contexts.
	GetAsym_key_name() IIdContext

	// SetLogin_name sets the login_name rule contexts.
	SetLogin_name(IIdContext)

	// SetDefault_database sets the default_database rule contexts.
	SetDefault_database(IIdContext)

	// SetDefault_laguage sets the default_laguage rule contexts.
	SetDefault_laguage(IIdContext)

	// SetCredential_name sets the credential_name rule contexts.
	SetCredential_name(IIdContext)

	// SetCertname sets the certname rule contexts.
	SetCertname(IIdContext)

	// SetAsym_key_name sets the asym_key_name rule contexts.
	SetAsym_key_name(IIdContext)

	// IsCreate_login_sql_serverContext differentiates from other interfaces.
	IsCreate_login_sql_serverContext()
}

ICreate_login_sql_serverContext is an interface to support dynamic dispatch.

type ICreate_master_key_azure_sqlContext

type ICreate_master_key_azure_sqlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// IsCreate_master_key_azure_sqlContext differentiates from other interfaces.
	IsCreate_master_key_azure_sqlContext()
}

ICreate_master_key_azure_sqlContext is an interface to support dynamic dispatch.

type ICreate_master_key_sql_serverContext

type ICreate_master_key_sql_serverContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// IsCreate_master_key_sql_serverContext differentiates from other interfaces.
	IsCreate_master_key_sql_serverContext()
}

ICreate_master_key_sql_serverContext is an interface to support dynamic dispatch.

type ICreate_or_alter_broker_priorityContext

type ICreate_or_alter_broker_priorityContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRemoteServiceName returns the RemoteServiceName token.
	GetRemoteServiceName() antlr.Token

	// GetPriorityValue returns the PriorityValue token.
	GetPriorityValue() antlr.Token

	// SetRemoteServiceName sets the RemoteServiceName token.
	SetRemoteServiceName(antlr.Token)

	// SetPriorityValue sets the PriorityValue token.
	SetPriorityValue(antlr.Token)

	// GetConversationPriorityName returns the ConversationPriorityName rule contexts.
	GetConversationPriorityName() IIdContext

	// SetConversationPriorityName sets the ConversationPriorityName rule contexts.
	SetConversationPriorityName(IIdContext)

	// IsCreate_or_alter_broker_priorityContext differentiates from other interfaces.
	IsCreate_or_alter_broker_priorityContext()
}

ICreate_or_alter_broker_priorityContext is an interface to support dynamic dispatch.

type ICreate_or_alter_ddl_triggerContext

type ICreate_or_alter_ddl_triggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCreate_or_alter_ddl_triggerContext differentiates from other interfaces.
	IsCreate_or_alter_ddl_triggerContext()
}

ICreate_or_alter_ddl_triggerContext is an interface to support dynamic dispatch.

type ICreate_or_alter_dml_triggerContext

type ICreate_or_alter_dml_triggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCreate_or_alter_dml_triggerContext differentiates from other interfaces.
	IsCreate_or_alter_dml_triggerContext()
}

ICreate_or_alter_dml_triggerContext is an interface to support dynamic dispatch.

type ICreate_or_alter_event_sessionContext

type ICreate_or_alter_event_sessionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMax_memory returns the max_memory token.
	GetMax_memory() antlr.Token

	// GetMax_dispatch_latency_seconds returns the max_dispatch_latency_seconds token.
	GetMax_dispatch_latency_seconds() antlr.Token

	// GetMax_event_size returns the max_event_size token.
	GetMax_event_size() antlr.Token

	// SetMax_memory sets the max_memory token.
	SetMax_memory(antlr.Token)

	// SetMax_dispatch_latency_seconds sets the max_dispatch_latency_seconds token.
	SetMax_dispatch_latency_seconds(antlr.Token)

	// SetMax_event_size sets the max_event_size token.
	SetMax_event_size(antlr.Token)

	// GetEvent_session_name returns the event_session_name rule contexts.
	GetEvent_session_name() IIdContext

	// GetEvent_module_guid returns the event_module_guid rule contexts.
	GetEvent_module_guid() IIdContext

	// GetEvent_package_name returns the event_package_name rule contexts.
	GetEvent_package_name() IIdContext

	// GetEvent_name returns the event_name rule contexts.
	GetEvent_name() IIdContext

	// GetEvent_customizable_attributue returns the event_customizable_attributue rule contexts.
	GetEvent_customizable_attributue() IIdContext

	// GetAction_name returns the action_name rule contexts.
	GetAction_name() IIdContext

	// GetTarget_name returns the target_name rule contexts.
	GetTarget_name() IIdContext

	// GetTarget_parameter_name returns the target_parameter_name rule contexts.
	GetTarget_parameter_name() IIdContext

	// SetEvent_session_name sets the event_session_name rule contexts.
	SetEvent_session_name(IIdContext)

	// SetEvent_module_guid sets the event_module_guid rule contexts.
	SetEvent_module_guid(IIdContext)

	// SetEvent_package_name sets the event_package_name rule contexts.
	SetEvent_package_name(IIdContext)

	// SetEvent_name sets the event_name rule contexts.
	SetEvent_name(IIdContext)

	// SetEvent_customizable_attributue sets the event_customizable_attributue rule contexts.
	SetEvent_customizable_attributue(IIdContext)

	// SetAction_name sets the action_name rule contexts.
	SetAction_name(IIdContext)

	// SetTarget_name sets the target_name rule contexts.
	SetTarget_name(IIdContext)

	// SetTarget_parameter_name sets the target_parameter_name rule contexts.
	SetTarget_parameter_name(IIdContext)

	// IsCreate_or_alter_event_sessionContext differentiates from other interfaces.
	IsCreate_or_alter_event_sessionContext()
}

ICreate_or_alter_event_sessionContext is an interface to support dynamic dispatch.

type ICreate_or_alter_functionContext

type ICreate_or_alter_functionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCreate_or_alter_functionContext differentiates from other interfaces.
	IsCreate_or_alter_functionContext()
}

ICreate_or_alter_functionContext is an interface to support dynamic dispatch.

type ICreate_or_alter_procedureContext

type ICreate_or_alter_procedureContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetProc returns the proc token.
	GetProc() antlr.Token

	// SetProc sets the proc token.
	SetProc(antlr.Token)

	// IsCreate_or_alter_procedureContext differentiates from other interfaces.
	IsCreate_or_alter_procedureContext()
}

ICreate_or_alter_procedureContext is an interface to support dynamic dispatch.

type ICreate_or_alter_triggerContext

type ICreate_or_alter_triggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCreate_or_alter_triggerContext differentiates from other interfaces.
	IsCreate_or_alter_triggerContext()
}

ICreate_or_alter_triggerContext is an interface to support dynamic dispatch.

type ICreate_queueContext

type ICreate_queueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetQueue_name returns the queue_name rule contexts.
	GetQueue_name() IIdContext

	// GetFilegroup returns the filegroup rule contexts.
	GetFilegroup() IIdContext

	// SetQueue_name sets the queue_name rule contexts.
	SetQueue_name(IIdContext)

	// SetFilegroup sets the filegroup rule contexts.
	SetFilegroup(IIdContext)

	// IsCreate_queueContext differentiates from other interfaces.
	IsCreate_queueContext()
}

ICreate_queueContext is an interface to support dynamic dispatch.

type ICreate_remote_service_bindingContext

type ICreate_remote_service_bindingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRemote_service_name returns the remote_service_name token.
	GetRemote_service_name() antlr.Token

	// SetRemote_service_name sets the remote_service_name token.
	SetRemote_service_name(antlr.Token)

	// GetBinding_name returns the binding_name rule contexts.
	GetBinding_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// GetUser_name returns the user_name rule contexts.
	GetUser_name() IIdContext

	// SetBinding_name sets the binding_name rule contexts.
	SetBinding_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// SetUser_name sets the user_name rule contexts.
	SetUser_name(IIdContext)

	// IsCreate_remote_service_bindingContext differentiates from other interfaces.
	IsCreate_remote_service_bindingContext()
}

ICreate_remote_service_bindingContext is an interface to support dynamic dispatch.

type ICreate_resource_poolContext

type ICreate_resource_poolContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPool_name returns the pool_name rule contexts.
	GetPool_name() IIdContext

	// SetPool_name sets the pool_name rule contexts.
	SetPool_name(IIdContext)

	// IsCreate_resource_poolContext differentiates from other interfaces.
	IsCreate_resource_poolContext()
}

ICreate_resource_poolContext is an interface to support dynamic dispatch.

type ICreate_routeContext

type ICreate_routeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRoute_service_name returns the route_service_name token.
	GetRoute_service_name() antlr.Token

	// GetBroker_instance_identifier returns the broker_instance_identifier token.
	GetBroker_instance_identifier() antlr.Token

	// SetRoute_service_name sets the route_service_name token.
	SetRoute_service_name(antlr.Token)

	// SetBroker_instance_identifier sets the broker_instance_identifier token.
	SetBroker_instance_identifier(antlr.Token)

	// GetRoute_name returns the route_name rule contexts.
	GetRoute_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// SetRoute_name sets the route_name rule contexts.
	SetRoute_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// IsCreate_routeContext differentiates from other interfaces.
	IsCreate_routeContext()
}

ICreate_routeContext is an interface to support dynamic dispatch.

type ICreate_ruleContext

type ICreate_ruleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetRule_name returns the rule_name rule contexts.
	GetRule_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetRule_name sets the rule_name rule contexts.
	SetRule_name(IIdContext)

	// IsCreate_ruleContext differentiates from other interfaces.
	IsCreate_ruleContext()
}

ICreate_ruleContext is an interface to support dynamic dispatch.

type ICreate_schemaContext

type ICreate_schemaContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// GetObject_name returns the object_name rule contexts.
	GetObject_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// SetObject_name sets the object_name rule contexts.
	SetObject_name(IIdContext)

	// IsCreate_schemaContext differentiates from other interfaces.
	IsCreate_schemaContext()
}

ICreate_schemaContext is an interface to support dynamic dispatch.

type ICreate_schema_azure_sql_dw_and_pdwContext

type ICreate_schema_azure_sql_dw_and_pdwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// IsCreate_schema_azure_sql_dw_and_pdwContext differentiates from other interfaces.
	IsCreate_schema_azure_sql_dw_and_pdwContext()
}

ICreate_schema_azure_sql_dw_and_pdwContext is an interface to support dynamic dispatch.

type ICreate_search_property_listContext

type ICreate_search_property_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetNew_list_name returns the new_list_name rule contexts.
	GetNew_list_name() IIdContext

	// GetDatabase_name returns the database_name rule contexts.
	GetDatabase_name() IIdContext

	// GetSource_list_name returns the source_list_name rule contexts.
	GetSource_list_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// SetNew_list_name sets the new_list_name rule contexts.
	SetNew_list_name(IIdContext)

	// SetDatabase_name sets the database_name rule contexts.
	SetDatabase_name(IIdContext)

	// SetSource_list_name sets the source_list_name rule contexts.
	SetSource_list_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// IsCreate_search_property_listContext differentiates from other interfaces.
	IsCreate_search_property_listContext()
}

ICreate_search_property_listContext is an interface to support dynamic dispatch.

type ICreate_security_policyContext

type ICreate_security_policyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetSecurity_policy_name returns the security_policy_name rule contexts.
	GetSecurity_policy_name() IIdContext

	// GetTvf_schema_name returns the tvf_schema_name rule contexts.
	GetTvf_schema_name() IIdContext

	// GetSecurity_predicate_function_name returns the security_predicate_function_name rule contexts.
	GetSecurity_predicate_function_name() IIdContext

	// GetColumn_name_or_arguments returns the column_name_or_arguments rule contexts.
	GetColumn_name_or_arguments() IIdContext

	// GetTable_schema_name returns the table_schema_name rule contexts.
	GetTable_schema_name() IIdContext

	// GetName returns the name rule contexts.
	GetName() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetSecurity_policy_name sets the security_policy_name rule contexts.
	SetSecurity_policy_name(IIdContext)

	// SetTvf_schema_name sets the tvf_schema_name rule contexts.
	SetTvf_schema_name(IIdContext)

	// SetSecurity_predicate_function_name sets the security_predicate_function_name rule contexts.
	SetSecurity_predicate_function_name(IIdContext)

	// SetColumn_name_or_arguments sets the column_name_or_arguments rule contexts.
	SetColumn_name_or_arguments(IIdContext)

	// SetTable_schema_name sets the table_schema_name rule contexts.
	SetTable_schema_name(IIdContext)

	// SetName sets the name rule contexts.
	SetName(IIdContext)

	// IsCreate_security_policyContext differentiates from other interfaces.
	IsCreate_security_policyContext()
}

ICreate_security_policyContext is an interface to support dynamic dispatch.

type ICreate_sequenceContext

type ICreate_sequenceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetSequence_name returns the sequence_name rule contexts.
	GetSequence_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetSequence_name sets the sequence_name rule contexts.
	SetSequence_name(IIdContext)

	// IsCreate_sequenceContext differentiates from other interfaces.
	IsCreate_sequenceContext()
}

ICreate_sequenceContext is an interface to support dynamic dispatch.

type ICreate_server_auditContext

type ICreate_server_auditContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetFilepath returns the filepath token.
	GetFilepath() antlr.Token

	// GetMax_rollover_files returns the max_rollover_files token.
	GetMax_rollover_files() antlr.Token

	// GetMax_files returns the max_files token.
	GetMax_files() antlr.Token

	// GetQueue_delay returns the queue_delay token.
	GetQueue_delay() antlr.Token

	// SetFilepath sets the filepath token.
	SetFilepath(antlr.Token)

	// SetMax_rollover_files sets the max_rollover_files token.
	SetMax_rollover_files(antlr.Token)

	// SetMax_files sets the max_files token.
	SetMax_files(antlr.Token)

	// SetQueue_delay sets the queue_delay token.
	SetQueue_delay(antlr.Token)

	// GetAudit_name returns the audit_name rule contexts.
	GetAudit_name() IIdContext

	// GetAudit_guid returns the audit_guid rule contexts.
	GetAudit_guid() IIdContext

	// GetEvent_field_name returns the event_field_name rule contexts.
	GetEvent_field_name() IIdContext

	// GetNew_audit_name returns the new_audit_name rule contexts.
	GetNew_audit_name() IIdContext

	// SetAudit_name sets the audit_name rule contexts.
	SetAudit_name(IIdContext)

	// SetAudit_guid sets the audit_guid rule contexts.
	SetAudit_guid(IIdContext)

	// SetEvent_field_name sets the event_field_name rule contexts.
	SetEvent_field_name(IIdContext)

	// SetNew_audit_name sets the new_audit_name rule contexts.
	SetNew_audit_name(IIdContext)

	// IsCreate_server_auditContext differentiates from other interfaces.
	IsCreate_server_auditContext()
}

ICreate_server_auditContext is an interface to support dynamic dispatch.

type ICreate_server_audit_specificationContext

type ICreate_server_audit_specificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAudit_specification_name returns the audit_specification_name rule contexts.
	GetAudit_specification_name() IIdContext

	// GetAudit_name returns the audit_name rule contexts.
	GetAudit_name() IIdContext

	// GetAudit_action_group_name returns the audit_action_group_name rule contexts.
	GetAudit_action_group_name() IIdContext

	// SetAudit_specification_name sets the audit_specification_name rule contexts.
	SetAudit_specification_name(IIdContext)

	// SetAudit_name sets the audit_name rule contexts.
	SetAudit_name(IIdContext)

	// SetAudit_action_group_name sets the audit_action_group_name rule contexts.
	SetAudit_action_group_name(IIdContext)

	// IsCreate_server_audit_specificationContext differentiates from other interfaces.
	IsCreate_server_audit_specificationContext()
}

ICreate_server_audit_specificationContext is an interface to support dynamic dispatch.

type ICreate_server_roleContext

type ICreate_server_roleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetServer_role returns the server_role rule contexts.
	GetServer_role() IIdContext

	// GetServer_principal returns the server_principal rule contexts.
	GetServer_principal() IIdContext

	// SetServer_role sets the server_role rule contexts.
	SetServer_role(IIdContext)

	// SetServer_principal sets the server_principal rule contexts.
	SetServer_principal(IIdContext)

	// IsCreate_server_roleContext differentiates from other interfaces.
	IsCreate_server_roleContext()
}

ICreate_server_roleContext is an interface to support dynamic dispatch.

type ICreate_serviceContext

type ICreate_serviceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCreate_service_name returns the create_service_name rule contexts.
	GetCreate_service_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetQueue_name returns the queue_name rule contexts.
	GetQueue_name() IIdContext

	// SetCreate_service_name sets the create_service_name rule contexts.
	SetCreate_service_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetQueue_name sets the queue_name rule contexts.
	SetQueue_name(IIdContext)

	// IsCreate_serviceContext differentiates from other interfaces.
	IsCreate_serviceContext()
}

ICreate_serviceContext is an interface to support dynamic dispatch.

type ICreate_statisticsContext

type ICreate_statisticsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCreate_statisticsContext differentiates from other interfaces.
	IsCreate_statisticsContext()
}

ICreate_statisticsContext is an interface to support dynamic dispatch.

type ICreate_symmetric_keyContext

type ICreate_symmetric_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetKey_pass_phrase returns the key_pass_phrase token.
	GetKey_pass_phrase() antlr.Token

	// GetIdentity_phrase returns the identity_phrase token.
	GetIdentity_phrase() antlr.Token

	// GetProvider_key_name returns the provider_key_name token.
	GetProvider_key_name() antlr.Token

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// SetKey_pass_phrase sets the key_pass_phrase token.
	SetKey_pass_phrase(antlr.Token)

	// SetIdentity_phrase sets the identity_phrase token.
	SetIdentity_phrase(antlr.Token)

	// SetProvider_key_name sets the provider_key_name token.
	SetProvider_key_name(antlr.Token)

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// GetKey_name returns the key_name rule contexts.
	GetKey_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// GetProvider_name returns the provider_name rule contexts.
	GetProvider_name() IIdContext

	// GetCertificate_name returns the certificate_name rule contexts.
	GetCertificate_name() IIdContext

	// GetSymmetric_key_name returns the symmetric_key_name rule contexts.
	GetSymmetric_key_name() IIdContext

	// GetAsym_key_name returns the asym_key_name rule contexts.
	GetAsym_key_name() IIdContext

	// SetKey_name sets the key_name rule contexts.
	SetKey_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// SetProvider_name sets the provider_name rule contexts.
	SetProvider_name(IIdContext)

	// SetCertificate_name sets the certificate_name rule contexts.
	SetCertificate_name(IIdContext)

	// SetSymmetric_key_name sets the symmetric_key_name rule contexts.
	SetSymmetric_key_name(IIdContext)

	// SetAsym_key_name sets the asym_key_name rule contexts.
	SetAsym_key_name(IIdContext)

	// IsCreate_symmetric_keyContext differentiates from other interfaces.
	IsCreate_symmetric_keyContext()
}

ICreate_symmetric_keyContext is an interface to support dynamic dispatch.

type ICreate_synonymContext

type ICreate_synonymContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name_1 returns the schema_name_1 rule contexts.
	GetSchema_name_1() IIdContext

	// GetSynonym_name returns the synonym_name rule contexts.
	GetSynonym_name() IIdContext

	// GetServer_name returns the server_name rule contexts.
	GetServer_name() IIdContext

	// GetDatabase_name returns the database_name rule contexts.
	GetDatabase_name() IIdContext

	// GetSchema_name_2 returns the schema_name_2 rule contexts.
	GetSchema_name_2() IIdContext

	// GetObject_name returns the object_name rule contexts.
	GetObject_name() IIdContext

	// GetDatabase_or_schema2 returns the database_or_schema2 rule contexts.
	GetDatabase_or_schema2() IIdContext

	// GetSchema_id_2_or_object_name returns the schema_id_2_or_object_name rule contexts.
	GetSchema_id_2_or_object_name() IIdContext

	// SetSchema_name_1 sets the schema_name_1 rule contexts.
	SetSchema_name_1(IIdContext)

	// SetSynonym_name sets the synonym_name rule contexts.
	SetSynonym_name(IIdContext)

	// SetServer_name sets the server_name rule contexts.
	SetServer_name(IIdContext)

	// SetDatabase_name sets the database_name rule contexts.
	SetDatabase_name(IIdContext)

	// SetSchema_name_2 sets the schema_name_2 rule contexts.
	SetSchema_name_2(IIdContext)

	// SetObject_name sets the object_name rule contexts.
	SetObject_name(IIdContext)

	// SetDatabase_or_schema2 sets the database_or_schema2 rule contexts.
	SetDatabase_or_schema2(IIdContext)

	// SetSchema_id_2_or_object_name sets the schema_id_2_or_object_name rule contexts.
	SetSchema_id_2_or_object_name(IIdContext)

	// IsCreate_synonymContext differentiates from other interfaces.
	IsCreate_synonymContext()
}

ICreate_synonymContext is an interface to support dynamic dispatch.

type ICreate_tableContext

type ICreate_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCreate_tableContext differentiates from other interfaces.
	IsCreate_tableContext()
}

ICreate_tableContext is an interface to support dynamic dispatch.

type ICreate_typeContext

type ICreate_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetName returns the name rule contexts.
	GetName() ISimple_nameContext

	// SetName sets the name rule contexts.
	SetName(ISimple_nameContext)

	// IsCreate_typeContext differentiates from other interfaces.
	IsCreate_typeContext()
}

ICreate_typeContext is an interface to support dynamic dispatch.

type ICreate_userContext

type ICreate_userContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// GetUser_name returns the user_name rule contexts.
	GetUser_name() IIdContext

	// GetLogin_name returns the login_name rule contexts.
	GetLogin_name() IIdContext

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetWindows_principal returns the windows_principal rule contexts.
	GetWindows_principal() IIdContext

	// GetLanguage_name_or_alias returns the language_name_or_alias rule contexts.
	GetLanguage_name_or_alias() IIdContext

	// GetAzure_Active_Directory_principal returns the Azure_Active_Directory_principal rule contexts.
	GetAzure_Active_Directory_principal() IIdContext

	// GetCert_name returns the cert_name rule contexts.
	GetCert_name() IIdContext

	// GetAsym_key_name returns the asym_key_name rule contexts.
	GetAsym_key_name() IIdContext

	// SetUser_name sets the user_name rule contexts.
	SetUser_name(IIdContext)

	// SetLogin_name sets the login_name rule contexts.
	SetLogin_name(IIdContext)

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetWindows_principal sets the windows_principal rule contexts.
	SetWindows_principal(IIdContext)

	// SetLanguage_name_or_alias sets the language_name_or_alias rule contexts.
	SetLanguage_name_or_alias(IIdContext)

	// SetAzure_Active_Directory_principal sets the Azure_Active_Directory_principal rule contexts.
	SetAzure_Active_Directory_principal(IIdContext)

	// SetCert_name sets the cert_name rule contexts.
	SetCert_name(IIdContext)

	// SetAsym_key_name sets the asym_key_name rule contexts.
	SetAsym_key_name(IIdContext)

	// IsCreate_userContext differentiates from other interfaces.
	IsCreate_userContext()
}

ICreate_userContext is an interface to support dynamic dispatch.

type ICreate_user_azure_sql_dwContext

type ICreate_user_azure_sql_dwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetUser_name returns the user_name rule contexts.
	GetUser_name() IIdContext

	// GetLogin_name returns the login_name rule contexts.
	GetLogin_name() IIdContext

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetAzure_Active_Directory_principal returns the Azure_Active_Directory_principal rule contexts.
	GetAzure_Active_Directory_principal() IIdContext

	// SetUser_name sets the user_name rule contexts.
	SetUser_name(IIdContext)

	// SetLogin_name sets the login_name rule contexts.
	SetLogin_name(IIdContext)

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetAzure_Active_Directory_principal sets the Azure_Active_Directory_principal rule contexts.
	SetAzure_Active_Directory_principal(IIdContext)

	// IsCreate_user_azure_sql_dwContext differentiates from other interfaces.
	IsCreate_user_azure_sql_dwContext()
}

ICreate_user_azure_sql_dwContext is an interface to support dynamic dispatch.

type ICreate_viewContext

type ICreate_viewContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCreate_viewContext differentiates from other interfaces.
	IsCreate_viewContext()
}

ICreate_viewContext is an interface to support dynamic dispatch.

type ICreate_workload_groupContext

type ICreate_workload_groupContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRequest_max_memory_grant returns the request_max_memory_grant token.
	GetRequest_max_memory_grant() antlr.Token

	// GetRequest_max_cpu_time_sec returns the request_max_cpu_time_sec token.
	GetRequest_max_cpu_time_sec() antlr.Token

	// GetRequest_memory_grant_timeout_sec returns the request_memory_grant_timeout_sec token.
	GetRequest_memory_grant_timeout_sec() antlr.Token

	// GetMax_dop returns the max_dop token.
	GetMax_dop() antlr.Token

	// GetGroup_max_requests returns the group_max_requests token.
	GetGroup_max_requests() antlr.Token

	// SetRequest_max_memory_grant sets the request_max_memory_grant token.
	SetRequest_max_memory_grant(antlr.Token)

	// SetRequest_max_cpu_time_sec sets the request_max_cpu_time_sec token.
	SetRequest_max_cpu_time_sec(antlr.Token)

	// SetRequest_memory_grant_timeout_sec sets the request_memory_grant_timeout_sec token.
	SetRequest_memory_grant_timeout_sec(antlr.Token)

	// SetMax_dop sets the max_dop token.
	SetMax_dop(antlr.Token)

	// SetGroup_max_requests sets the group_max_requests token.
	SetGroup_max_requests(antlr.Token)

	// GetWorkload_group_group_name returns the workload_group_group_name rule contexts.
	GetWorkload_group_group_name() IIdContext

	// GetWorkload_group_pool_name returns the workload_group_pool_name rule contexts.
	GetWorkload_group_pool_name() IIdContext

	// GetExternal_pool_name returns the external_pool_name rule contexts.
	GetExternal_pool_name() IIdContext

	// SetWorkload_group_group_name sets the workload_group_group_name rule contexts.
	SetWorkload_group_group_name(IIdContext)

	// SetWorkload_group_pool_name sets the workload_group_pool_name rule contexts.
	SetWorkload_group_pool_name(IIdContext)

	// SetExternal_pool_name sets the external_pool_name rule contexts.
	SetExternal_pool_name(IIdContext)

	// IsCreate_workload_groupContext differentiates from other interfaces.
	IsCreate_workload_groupContext()
}

ICreate_workload_groupContext is an interface to support dynamic dispatch.

type ICreate_xml_schema_collectionContext

type ICreate_xml_schema_collectionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRelational_schema returns the relational_schema rule contexts.
	GetRelational_schema() IIdContext

	// GetSql_identifier returns the sql_identifier rule contexts.
	GetSql_identifier() IIdContext

	// SetRelational_schema sets the relational_schema rule contexts.
	SetRelational_schema(IIdContext)

	// SetSql_identifier sets the sql_identifier rule contexts.
	SetSql_identifier(IIdContext)

	// IsCreate_xml_schema_collectionContext differentiates from other interfaces.
	IsCreate_xml_schema_collectionContext()
}

ICreate_xml_schema_collectionContext is an interface to support dynamic dispatch.

type ICursor_nameContext

type ICursor_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCursor_nameContext differentiates from other interfaces.
	IsCursor_nameContext()
}

ICursor_nameContext is an interface to support dynamic dispatch.

type ICursor_optionContext

type ICursor_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCursor_optionContext differentiates from other interfaces.
	IsCursor_optionContext()
}

ICursor_optionContext is an interface to support dynamic dispatch.

type ICursor_statementContext

type ICursor_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCursor_statementContext differentiates from other interfaces.
	IsCursor_statementContext()
}

ICursor_statementContext is an interface to support dynamic dispatch.

type IDENTITYContext

type IDENTITYContext struct {
	*Function_callContext
	// contains filtered or unexported fields
}

func NewIDENTITYContext

func NewIDENTITYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IDENTITYContext

func (*IDENTITYContext) AllCOMMA

func (s *IDENTITYContext) AllCOMMA() []antlr.TerminalNode

func (*IDENTITYContext) AllDECIMAL

func (s *IDENTITYContext) AllDECIMAL() []antlr.TerminalNode

func (*IDENTITYContext) COMMA

func (s *IDENTITYContext) COMMA(i int) antlr.TerminalNode

func (*IDENTITYContext) DECIMAL

func (s *IDENTITYContext) DECIMAL(i int) antlr.TerminalNode

func (*IDENTITYContext) Data_type

func (s *IDENTITYContext) Data_type() IData_typeContext

func (*IDENTITYContext) EnterRule

func (s *IDENTITYContext) EnterRule(listener antlr.ParseTreeListener)

func (*IDENTITYContext) ExitRule

func (s *IDENTITYContext) ExitRule(listener antlr.ParseTreeListener)

func (*IDENTITYContext) GetIncrement

func (s *IDENTITYContext) GetIncrement() antlr.Token

func (*IDENTITYContext) GetRuleContext

func (s *IDENTITYContext) GetRuleContext() antlr.RuleContext

func (*IDENTITYContext) GetSeed

func (s *IDENTITYContext) GetSeed() antlr.Token

func (*IDENTITYContext) IDENTITY

func (s *IDENTITYContext) IDENTITY() antlr.TerminalNode

func (*IDENTITYContext) LR_BRACKET

func (s *IDENTITYContext) LR_BRACKET() antlr.TerminalNode

func (*IDENTITYContext) RR_BRACKET

func (s *IDENTITYContext) RR_BRACKET() antlr.TerminalNode

func (*IDENTITYContext) SetIncrement

func (s *IDENTITYContext) SetIncrement(v antlr.Token)

func (*IDENTITYContext) SetSeed

func (s *IDENTITYContext) SetSeed(v antlr.Token)

type IData_typeContext

type IData_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsData_typeContext differentiates from other interfaces.
	IsData_typeContext()
}

IData_typeContext is an interface to support dynamic dispatch.

type IDatabase_file_specContext

type IDatabase_file_specContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDatabase_file_specContext differentiates from other interfaces.
	IsDatabase_file_specContext()
}

IDatabase_file_specContext is an interface to support dynamic dispatch.

type IDatabase_filestream_optionContext

type IDatabase_filestream_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDatabase_filestream_optionContext differentiates from other interfaces.
	IsDatabase_filestream_optionContext()
}

IDatabase_filestream_optionContext is an interface to support dynamic dispatch.

type IDatabase_mirroring_optionContext

type IDatabase_mirroring_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDatabase_mirroring_optionContext differentiates from other interfaces.
	IsDatabase_mirroring_optionContext()
}

IDatabase_mirroring_optionContext is an interface to support dynamic dispatch.

type IDatabase_optionspecContext

type IDatabase_optionspecContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDatabase_optionspecContext differentiates from other interfaces.
	IsDatabase_optionspecContext()
}

IDatabase_optionspecContext is an interface to support dynamic dispatch.

type IDate_correlation_optimization_optionContext

type IDate_correlation_optimization_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDate_correlation_optimization_optionContext differentiates from other interfaces.
	IsDate_correlation_optimization_optionContext()
}

IDate_correlation_optimization_optionContext is an interface to support dynamic dispatch.

type IDate_optionsContext

type IDate_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDate_optionsContext differentiates from other interfaces.
	IsDate_optionsContext()
}

IDate_optionsContext is an interface to support dynamic dispatch.

type IDb_encryption_optionContext

type IDb_encryption_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDb_encryption_optionContext differentiates from other interfaces.
	IsDb_encryption_optionContext()
}

IDb_encryption_optionContext is an interface to support dynamic dispatch.

type IDb_state_optionContext

type IDb_state_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDb_state_optionContext differentiates from other interfaces.
	IsDb_state_optionContext()
}

IDb_state_optionContext is an interface to support dynamic dispatch.

type IDb_update_optionContext

type IDb_update_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDb_update_optionContext differentiates from other interfaces.
	IsDb_update_optionContext()
}

IDb_update_optionContext is an interface to support dynamic dispatch.

type IDb_user_access_optionContext

type IDb_user_access_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDb_user_access_optionContext differentiates from other interfaces.
	IsDb_user_access_optionContext()
}

IDb_user_access_optionContext is an interface to support dynamic dispatch.

type IDbcc_clauseContext

type IDbcc_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetName returns the name rule contexts.
	GetName() ISimple_idContext

	// SetName sets the name rule contexts.
	SetName(ISimple_idContext)

	// IsDbcc_clauseContext differentiates from other interfaces.
	IsDbcc_clauseContext()
}

IDbcc_clauseContext is an interface to support dynamic dispatch.

type IDbcc_optionsContext

type IDbcc_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDbcc_optionsContext differentiates from other interfaces.
	IsDbcc_optionsContext()
}

IDbcc_optionsContext is an interface to support dynamic dispatch.

type IDdl_clauseContext

type IDdl_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDdl_clauseContext differentiates from other interfaces.
	IsDdl_clauseContext()
}

IDdl_clauseContext is an interface to support dynamic dispatch.

type IDdl_objectContext

type IDdl_objectContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDdl_objectContext differentiates from other interfaces.
	IsDdl_objectContext()
}

IDdl_objectContext is an interface to support dynamic dispatch.

type IDdl_trigger_operationContext

type IDdl_trigger_operationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDdl_trigger_operationContext differentiates from other interfaces.
	IsDdl_trigger_operationContext()
}

IDdl_trigger_operationContext is an interface to support dynamic dispatch.

type IDeclare_cursorContext

type IDeclare_cursorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeclare_cursorContext differentiates from other interfaces.
	IsDeclare_cursorContext()
}

IDeclare_cursorContext is an interface to support dynamic dispatch.

type IDeclare_localContext

type IDeclare_localContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeclare_localContext differentiates from other interfaces.
	IsDeclare_localContext()
}

IDeclare_localContext is an interface to support dynamic dispatch.

type IDeclare_set_cursor_commonContext

type IDeclare_set_cursor_commonContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeclare_set_cursor_commonContext differentiates from other interfaces.
	IsDeclare_set_cursor_commonContext()
}

IDeclare_set_cursor_commonContext is an interface to support dynamic dispatch.

type IDeclare_set_cursor_common_partialContext

type IDeclare_set_cursor_common_partialContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDeclare_set_cursor_common_partialContext differentiates from other interfaces.
	IsDeclare_set_cursor_common_partialContext()
}

IDeclare_set_cursor_common_partialContext is an interface to support dynamic dispatch.

type IDeclare_statementContext

type IDeclare_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetXml_namespace_uri returns the xml_namespace_uri token.
	GetXml_namespace_uri() antlr.Token

	// SetXml_namespace_uri sets the xml_namespace_uri token.
	SetXml_namespace_uri(antlr.Token)

	// IsDeclare_statementContext differentiates from other interfaces.
	IsDeclare_statementContext()
}

IDeclare_statementContext is an interface to support dynamic dispatch.

type IDecryption_mechanismContext

type IDecryption_mechanismContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCertificate_name returns the certificate_name rule contexts.
	GetCertificate_name() IIdContext

	// GetAsym_key_name returns the asym_key_name rule contexts.
	GetAsym_key_name() IIdContext

	// GetDecrypting_Key_name returns the decrypting_Key_name rule contexts.
	GetDecrypting_Key_name() IIdContext

	// SetCertificate_name sets the certificate_name rule contexts.
	SetCertificate_name(IIdContext)

	// SetAsym_key_name sets the asym_key_name rule contexts.
	SetAsym_key_name(IIdContext)

	// SetDecrypting_Key_name sets the decrypting_Key_name rule contexts.
	SetDecrypting_Key_name(IIdContext)

	// IsDecryption_mechanismContext differentiates from other interfaces.
	IsDecryption_mechanismContext()
}

IDecryption_mechanismContext is an interface to support dynamic dispatch.

type IDefault_valueContext

type IDefault_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDefault_valueContext differentiates from other interfaces.
	IsDefault_valueContext()
}

IDefault_valueContext is an interface to support dynamic dispatch.

type IDelayed_durability_optionContext

type IDelayed_durability_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDelayed_durability_optionContext differentiates from other interfaces.
	IsDelayed_durability_optionContext()
}

IDelayed_durability_optionContext is an interface to support dynamic dispatch.

type IDelete_statementContext

type IDelete_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCursor_var returns the cursor_var token.
	GetCursor_var() antlr.Token

	// SetCursor_var sets the cursor_var token.
	SetCursor_var(antlr.Token)

	// IsDelete_statementContext differentiates from other interfaces.
	IsDelete_statementContext()
}

IDelete_statementContext is an interface to support dynamic dispatch.

type IDelete_statement_fromContext

type IDelete_statement_fromContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetTable_var returns the table_var token.
	GetTable_var() antlr.Token

	// SetTable_var sets the table_var token.
	SetTable_var(antlr.Token)

	// IsDelete_statement_fromContext differentiates from other interfaces.
	IsDelete_statement_fromContext()
}

IDelete_statement_fromContext is an interface to support dynamic dispatch.

type IDerived_tableContext

type IDerived_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDerived_tableContext differentiates from other interfaces.
	IsDerived_tableContext()
}

IDerived_tableContext is an interface to support dynamic dispatch.

type IDisable_triggerContext

type IDisable_triggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetTrigger_name returns the trigger_name rule contexts.
	GetTrigger_name() IIdContext

	// GetSchema_id returns the schema_id rule contexts.
	GetSchema_id() IIdContext

	// GetObject_name returns the object_name rule contexts.
	GetObject_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetTrigger_name sets the trigger_name rule contexts.
	SetTrigger_name(IIdContext)

	// SetSchema_id sets the schema_id rule contexts.
	SetSchema_id(IIdContext)

	// SetObject_name sets the object_name rule contexts.
	SetObject_name(IIdContext)

	// IsDisable_triggerContext differentiates from other interfaces.
	IsDisable_triggerContext()
}

IDisable_triggerContext is an interface to support dynamic dispatch.

type IDml_clauseContext

type IDml_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDml_clauseContext differentiates from other interfaces.
	IsDml_clauseContext()
}

IDml_clauseContext is an interface to support dynamic dispatch.

type IDml_trigger_operationContext

type IDml_trigger_operationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDml_trigger_operationContext differentiates from other interfaces.
	IsDml_trigger_operationContext()
}

IDml_trigger_operationContext is an interface to support dynamic dispatch.

type IDml_trigger_optionContext

type IDml_trigger_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDml_trigger_optionContext differentiates from other interfaces.
	IsDml_trigger_optionContext()
}

IDml_trigger_optionContext is an interface to support dynamic dispatch.

type IDrop_aggregateContext

type IDrop_aggregateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetAggregate_name returns the aggregate_name rule contexts.
	GetAggregate_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetAggregate_name sets the aggregate_name rule contexts.
	SetAggregate_name(IIdContext)

	// IsDrop_aggregateContext differentiates from other interfaces.
	IsDrop_aggregateContext()
}

IDrop_aggregateContext is an interface to support dynamic dispatch.

type IDrop_application_roleContext

type IDrop_application_roleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRolename returns the rolename rule contexts.
	GetRolename() IIdContext

	// SetRolename sets the rolename rule contexts.
	SetRolename(IIdContext)

	// IsDrop_application_roleContext differentiates from other interfaces.
	IsDrop_application_roleContext()
}

IDrop_application_roleContext is an interface to support dynamic dispatch.

type IDrop_assemblyContext

type IDrop_assemblyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAssembly_name returns the assembly_name rule contexts.
	GetAssembly_name() IIdContext

	// SetAssembly_name sets the assembly_name rule contexts.
	SetAssembly_name(IIdContext)

	// IsDrop_assemblyContext differentiates from other interfaces.
	IsDrop_assemblyContext()
}

IDrop_assemblyContext is an interface to support dynamic dispatch.

type IDrop_asymmetric_keyContext

type IDrop_asymmetric_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetKey_name returns the key_name rule contexts.
	GetKey_name() IIdContext

	// SetKey_name sets the key_name rule contexts.
	SetKey_name(IIdContext)

	// IsDrop_asymmetric_keyContext differentiates from other interfaces.
	IsDrop_asymmetric_keyContext()
}

IDrop_asymmetric_keyContext is an interface to support dynamic dispatch.

type IDrop_availability_groupContext

type IDrop_availability_groupContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetGroup_name returns the group_name rule contexts.
	GetGroup_name() IIdContext

	// SetGroup_name sets the group_name rule contexts.
	SetGroup_name(IIdContext)

	// IsDrop_availability_groupContext differentiates from other interfaces.
	IsDrop_availability_groupContext()
}

IDrop_availability_groupContext is an interface to support dynamic dispatch.

type IDrop_backward_compatible_indexContext

type IDrop_backward_compatible_indexContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// GetTable_or_view_name returns the table_or_view_name rule contexts.
	GetTable_or_view_name() IIdContext

	// GetIndex_name returns the index_name rule contexts.
	GetIndex_name() IIdContext

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// SetTable_or_view_name sets the table_or_view_name rule contexts.
	SetTable_or_view_name(IIdContext)

	// SetIndex_name sets the index_name rule contexts.
	SetIndex_name(IIdContext)

	// IsDrop_backward_compatible_indexContext differentiates from other interfaces.
	IsDrop_backward_compatible_indexContext()
}

IDrop_backward_compatible_indexContext is an interface to support dynamic dispatch.

type IDrop_broker_priorityContext

type IDrop_broker_priorityContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetConversationPriorityName returns the ConversationPriorityName rule contexts.
	GetConversationPriorityName() IIdContext

	// SetConversationPriorityName sets the ConversationPriorityName rule contexts.
	SetConversationPriorityName(IIdContext)

	// IsDrop_broker_priorityContext differentiates from other interfaces.
	IsDrop_broker_priorityContext()
}

IDrop_broker_priorityContext is an interface to support dynamic dispatch.

type IDrop_certificateContext

type IDrop_certificateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCertificate_name returns the certificate_name rule contexts.
	GetCertificate_name() IIdContext

	// SetCertificate_name sets the certificate_name rule contexts.
	SetCertificate_name(IIdContext)

	// IsDrop_certificateContext differentiates from other interfaces.
	IsDrop_certificateContext()
}

IDrop_certificateContext is an interface to support dynamic dispatch.

type IDrop_column_encryption_keyContext

type IDrop_column_encryption_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetKey_name returns the key_name rule contexts.
	GetKey_name() IIdContext

	// SetKey_name sets the key_name rule contexts.
	SetKey_name(IIdContext)

	// IsDrop_column_encryption_keyContext differentiates from other interfaces.
	IsDrop_column_encryption_keyContext()
}

IDrop_column_encryption_keyContext is an interface to support dynamic dispatch.

type IDrop_column_master_keyContext

type IDrop_column_master_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetKey_name returns the key_name rule contexts.
	GetKey_name() IIdContext

	// SetKey_name sets the key_name rule contexts.
	SetKey_name(IIdContext)

	// IsDrop_column_master_keyContext differentiates from other interfaces.
	IsDrop_column_master_keyContext()
}

IDrop_column_master_keyContext is an interface to support dynamic dispatch.

type IDrop_contractContext

type IDrop_contractContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDropped_contract_name returns the dropped_contract_name rule contexts.
	GetDropped_contract_name() IIdContext

	// SetDropped_contract_name sets the dropped_contract_name rule contexts.
	SetDropped_contract_name(IIdContext)

	// IsDrop_contractContext differentiates from other interfaces.
	IsDrop_contractContext()
}

IDrop_contractContext is an interface to support dynamic dispatch.

type IDrop_credentialContext

type IDrop_credentialContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCredential_name returns the credential_name rule contexts.
	GetCredential_name() IIdContext

	// SetCredential_name sets the credential_name rule contexts.
	SetCredential_name(IIdContext)

	// IsDrop_credentialContext differentiates from other interfaces.
	IsDrop_credentialContext()
}

IDrop_credentialContext is an interface to support dynamic dispatch.

type IDrop_cryptograhic_providerContext

type IDrop_cryptograhic_providerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetProvider_name returns the provider_name rule contexts.
	GetProvider_name() IIdContext

	// SetProvider_name sets the provider_name rule contexts.
	SetProvider_name(IIdContext)

	// IsDrop_cryptograhic_providerContext differentiates from other interfaces.
	IsDrop_cryptograhic_providerContext()
}

IDrop_cryptograhic_providerContext is an interface to support dynamic dispatch.

type IDrop_databaseContext

type IDrop_databaseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDatabase_name_or_database_snapshot_name returns the database_name_or_database_snapshot_name rule contexts.
	GetDatabase_name_or_database_snapshot_name() IIdContext

	// SetDatabase_name_or_database_snapshot_name sets the database_name_or_database_snapshot_name rule contexts.
	SetDatabase_name_or_database_snapshot_name(IIdContext)

	// IsDrop_databaseContext differentiates from other interfaces.
	IsDrop_databaseContext()
}

IDrop_databaseContext is an interface to support dynamic dispatch.

type IDrop_database_audit_specificationContext

type IDrop_database_audit_specificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAudit_specification_name returns the audit_specification_name rule contexts.
	GetAudit_specification_name() IIdContext

	// SetAudit_specification_name sets the audit_specification_name rule contexts.
	SetAudit_specification_name(IIdContext)

	// IsDrop_database_audit_specificationContext differentiates from other interfaces.
	IsDrop_database_audit_specificationContext()
}

IDrop_database_audit_specificationContext is an interface to support dynamic dispatch.

type IDrop_database_scoped_credentialContext

type IDrop_database_scoped_credentialContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCredential_name returns the credential_name rule contexts.
	GetCredential_name() IIdContext

	// SetCredential_name sets the credential_name rule contexts.
	SetCredential_name(IIdContext)

	// IsDrop_database_scoped_credentialContext differentiates from other interfaces.
	IsDrop_database_scoped_credentialContext()
}

IDrop_database_scoped_credentialContext is an interface to support dynamic dispatch.

type IDrop_db_roleContext

type IDrop_db_roleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRole_name returns the role_name rule contexts.
	GetRole_name() IIdContext

	// SetRole_name sets the role_name rule contexts.
	SetRole_name(IIdContext)

	// IsDrop_db_roleContext differentiates from other interfaces.
	IsDrop_db_roleContext()
}

IDrop_db_roleContext is an interface to support dynamic dispatch.

type IDrop_ddl_triggerContext

type IDrop_ddl_triggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDrop_ddl_triggerContext differentiates from other interfaces.
	IsDrop_ddl_triggerContext()
}

IDrop_ddl_triggerContext is an interface to support dynamic dispatch.

type IDrop_defaultContext

type IDrop_defaultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetDefault_name returns the default_name rule contexts.
	GetDefault_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetDefault_name sets the default_name rule contexts.
	SetDefault_name(IIdContext)

	// IsDrop_defaultContext differentiates from other interfaces.
	IsDrop_defaultContext()
}

IDrop_defaultContext is an interface to support dynamic dispatch.

type IDrop_dml_triggerContext

type IDrop_dml_triggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDrop_dml_triggerContext differentiates from other interfaces.
	IsDrop_dml_triggerContext()
}

IDrop_dml_triggerContext is an interface to support dynamic dispatch.

type IDrop_endpointContext

type IDrop_endpointContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetEndPointName returns the endPointName rule contexts.
	GetEndPointName() IIdContext

	// SetEndPointName sets the endPointName rule contexts.
	SetEndPointName(IIdContext)

	// IsDrop_endpointContext differentiates from other interfaces.
	IsDrop_endpointContext()
}

IDrop_endpointContext is an interface to support dynamic dispatch.

type IDrop_event_notificationsContext

type IDrop_event_notificationsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetNotification_name returns the notification_name rule contexts.
	GetNotification_name() IIdContext

	// GetQueue_name returns the queue_name rule contexts.
	GetQueue_name() IIdContext

	// SetNotification_name sets the notification_name rule contexts.
	SetNotification_name(IIdContext)

	// SetQueue_name sets the queue_name rule contexts.
	SetQueue_name(IIdContext)

	// IsDrop_event_notificationsContext differentiates from other interfaces.
	IsDrop_event_notificationsContext()
}

IDrop_event_notificationsContext is an interface to support dynamic dispatch.

type IDrop_event_sessionContext

type IDrop_event_sessionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetEvent_session_name returns the event_session_name rule contexts.
	GetEvent_session_name() IIdContext

	// SetEvent_session_name sets the event_session_name rule contexts.
	SetEvent_session_name(IIdContext)

	// IsDrop_event_sessionContext differentiates from other interfaces.
	IsDrop_event_sessionContext()
}

IDrop_event_sessionContext is an interface to support dynamic dispatch.

type IDrop_external_data_sourceContext

type IDrop_external_data_sourceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetExternal_data_source_name returns the external_data_source_name rule contexts.
	GetExternal_data_source_name() IIdContext

	// SetExternal_data_source_name sets the external_data_source_name rule contexts.
	SetExternal_data_source_name(IIdContext)

	// IsDrop_external_data_sourceContext differentiates from other interfaces.
	IsDrop_external_data_sourceContext()
}

IDrop_external_data_sourceContext is an interface to support dynamic dispatch.

type IDrop_external_file_formatContext

type IDrop_external_file_formatContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetExternal_file_format_name returns the external_file_format_name rule contexts.
	GetExternal_file_format_name() IIdContext

	// SetExternal_file_format_name sets the external_file_format_name rule contexts.
	SetExternal_file_format_name(IIdContext)

	// IsDrop_external_file_formatContext differentiates from other interfaces.
	IsDrop_external_file_formatContext()
}

IDrop_external_file_formatContext is an interface to support dynamic dispatch.

type IDrop_external_libraryContext

type IDrop_external_libraryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetLibrary_name returns the library_name rule contexts.
	GetLibrary_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// SetLibrary_name sets the library_name rule contexts.
	SetLibrary_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// IsDrop_external_libraryContext differentiates from other interfaces.
	IsDrop_external_libraryContext()
}

IDrop_external_libraryContext is an interface to support dynamic dispatch.

type IDrop_external_resource_poolContext

type IDrop_external_resource_poolContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPool_name returns the pool_name rule contexts.
	GetPool_name() IIdContext

	// SetPool_name sets the pool_name rule contexts.
	SetPool_name(IIdContext)

	// IsDrop_external_resource_poolContext differentiates from other interfaces.
	IsDrop_external_resource_poolContext()
}

IDrop_external_resource_poolContext is an interface to support dynamic dispatch.

type IDrop_external_tableContext

type IDrop_external_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDatabase_name returns the database_name rule contexts.
	GetDatabase_name() IIdContext

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetTable returns the table rule contexts.
	GetTable() IIdContext

	// SetDatabase_name sets the database_name rule contexts.
	SetDatabase_name(IIdContext)

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetTable sets the table rule contexts.
	SetTable(IIdContext)

	// IsDrop_external_tableContext differentiates from other interfaces.
	IsDrop_external_tableContext()
}

IDrop_external_tableContext is an interface to support dynamic dispatch.

type IDrop_fulltext_catalogContext

type IDrop_fulltext_catalogContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCatalog_name returns the catalog_name rule contexts.
	GetCatalog_name() IIdContext

	// SetCatalog_name sets the catalog_name rule contexts.
	SetCatalog_name(IIdContext)

	// IsDrop_fulltext_catalogContext differentiates from other interfaces.
	IsDrop_fulltext_catalogContext()
}

IDrop_fulltext_catalogContext is an interface to support dynamic dispatch.

type IDrop_fulltext_indexContext

type IDrop_fulltext_indexContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetTable returns the table rule contexts.
	GetTable() IIdContext

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetTable sets the table rule contexts.
	SetTable(IIdContext)

	// IsDrop_fulltext_indexContext differentiates from other interfaces.
	IsDrop_fulltext_indexContext()
}

IDrop_fulltext_indexContext is an interface to support dynamic dispatch.

type IDrop_fulltext_stoplistContext

type IDrop_fulltext_stoplistContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetStoplist_name returns the stoplist_name rule contexts.
	GetStoplist_name() IIdContext

	// SetStoplist_name sets the stoplist_name rule contexts.
	SetStoplist_name(IIdContext)

	// IsDrop_fulltext_stoplistContext differentiates from other interfaces.
	IsDrop_fulltext_stoplistContext()
}

IDrop_fulltext_stoplistContext is an interface to support dynamic dispatch.

type IDrop_functionContext

type IDrop_functionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDrop_functionContext differentiates from other interfaces.
	IsDrop_functionContext()
}

IDrop_functionContext is an interface to support dynamic dispatch.

type IDrop_indexContext

type IDrop_indexContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDrop_indexContext differentiates from other interfaces.
	IsDrop_indexContext()
}

IDrop_indexContext is an interface to support dynamic dispatch.

type IDrop_loginContext

type IDrop_loginContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetLogin_name returns the login_name rule contexts.
	GetLogin_name() IIdContext

	// SetLogin_name sets the login_name rule contexts.
	SetLogin_name(IIdContext)

	// IsDrop_loginContext differentiates from other interfaces.
	IsDrop_loginContext()
}

IDrop_loginContext is an interface to support dynamic dispatch.

type IDrop_master_keyContext

type IDrop_master_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDrop_master_keyContext differentiates from other interfaces.
	IsDrop_master_keyContext()
}

IDrop_master_keyContext is an interface to support dynamic dispatch.

type IDrop_message_typeContext

type IDrop_message_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMessage_type_name returns the message_type_name rule contexts.
	GetMessage_type_name() IIdContext

	// SetMessage_type_name sets the message_type_name rule contexts.
	SetMessage_type_name(IIdContext)

	// IsDrop_message_typeContext differentiates from other interfaces.
	IsDrop_message_typeContext()
}

IDrop_message_typeContext is an interface to support dynamic dispatch.

type IDrop_partition_functionContext

type IDrop_partition_functionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPartition_function_name returns the partition_function_name rule contexts.
	GetPartition_function_name() IIdContext

	// SetPartition_function_name sets the partition_function_name rule contexts.
	SetPartition_function_name(IIdContext)

	// IsDrop_partition_functionContext differentiates from other interfaces.
	IsDrop_partition_functionContext()
}

IDrop_partition_functionContext is an interface to support dynamic dispatch.

type IDrop_partition_schemeContext

type IDrop_partition_schemeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPartition_scheme_name returns the partition_scheme_name rule contexts.
	GetPartition_scheme_name() IIdContext

	// SetPartition_scheme_name sets the partition_scheme_name rule contexts.
	SetPartition_scheme_name(IIdContext)

	// IsDrop_partition_schemeContext differentiates from other interfaces.
	IsDrop_partition_schemeContext()
}

IDrop_partition_schemeContext is an interface to support dynamic dispatch.

type IDrop_procedureContext

type IDrop_procedureContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetProc returns the proc token.
	GetProc() antlr.Token

	// SetProc sets the proc token.
	SetProc(antlr.Token)

	// IsDrop_procedureContext differentiates from other interfaces.
	IsDrop_procedureContext()
}

IDrop_procedureContext is an interface to support dynamic dispatch.

type IDrop_queueContext

type IDrop_queueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDatabase_name returns the database_name rule contexts.
	GetDatabase_name() IIdContext

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetQueue_name returns the queue_name rule contexts.
	GetQueue_name() IIdContext

	// SetDatabase_name sets the database_name rule contexts.
	SetDatabase_name(IIdContext)

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetQueue_name sets the queue_name rule contexts.
	SetQueue_name(IIdContext)

	// IsDrop_queueContext differentiates from other interfaces.
	IsDrop_queueContext()
}

IDrop_queueContext is an interface to support dynamic dispatch.

type IDrop_relational_or_xml_or_spatial_indexContext

type IDrop_relational_or_xml_or_spatial_indexContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetIndex_name returns the index_name rule contexts.
	GetIndex_name() IIdContext

	// SetIndex_name sets the index_name rule contexts.
	SetIndex_name(IIdContext)

	// IsDrop_relational_or_xml_or_spatial_indexContext differentiates from other interfaces.
	IsDrop_relational_or_xml_or_spatial_indexContext()
}

IDrop_relational_or_xml_or_spatial_indexContext is an interface to support dynamic dispatch.

type IDrop_remote_service_bindingContext

type IDrop_remote_service_bindingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetBinding_name returns the binding_name rule contexts.
	GetBinding_name() IIdContext

	// SetBinding_name sets the binding_name rule contexts.
	SetBinding_name(IIdContext)

	// IsDrop_remote_service_bindingContext differentiates from other interfaces.
	IsDrop_remote_service_bindingContext()
}

IDrop_remote_service_bindingContext is an interface to support dynamic dispatch.

type IDrop_resource_poolContext

type IDrop_resource_poolContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPool_name returns the pool_name rule contexts.
	GetPool_name() IIdContext

	// SetPool_name sets the pool_name rule contexts.
	SetPool_name(IIdContext)

	// IsDrop_resource_poolContext differentiates from other interfaces.
	IsDrop_resource_poolContext()
}

IDrop_resource_poolContext is an interface to support dynamic dispatch.

type IDrop_routeContext

type IDrop_routeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRoute_name returns the route_name rule contexts.
	GetRoute_name() IIdContext

	// SetRoute_name sets the route_name rule contexts.
	SetRoute_name(IIdContext)

	// IsDrop_routeContext differentiates from other interfaces.
	IsDrop_routeContext()
}

IDrop_routeContext is an interface to support dynamic dispatch.

type IDrop_ruleContext

type IDrop_ruleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetRule_name returns the rule_name rule contexts.
	GetRule_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetRule_name sets the rule_name rule contexts.
	SetRule_name(IIdContext)

	// IsDrop_ruleContext differentiates from other interfaces.
	IsDrop_ruleContext()
}

IDrop_ruleContext is an interface to support dynamic dispatch.

type IDrop_schemaContext

type IDrop_schemaContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// IsDrop_schemaContext differentiates from other interfaces.
	IsDrop_schemaContext()
}

IDrop_schemaContext is an interface to support dynamic dispatch.

type IDrop_search_property_listContext

type IDrop_search_property_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetProperty_list_name returns the property_list_name rule contexts.
	GetProperty_list_name() IIdContext

	// SetProperty_list_name sets the property_list_name rule contexts.
	SetProperty_list_name(IIdContext)

	// IsDrop_search_property_listContext differentiates from other interfaces.
	IsDrop_search_property_listContext()
}

IDrop_search_property_listContext is an interface to support dynamic dispatch.

type IDrop_security_policyContext

type IDrop_security_policyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetSecurity_policy_name returns the security_policy_name rule contexts.
	GetSecurity_policy_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetSecurity_policy_name sets the security_policy_name rule contexts.
	SetSecurity_policy_name(IIdContext)

	// IsDrop_security_policyContext differentiates from other interfaces.
	IsDrop_security_policyContext()
}

IDrop_security_policyContext is an interface to support dynamic dispatch.

type IDrop_sequenceContext

type IDrop_sequenceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDatabase_name returns the database_name rule contexts.
	GetDatabase_name() IIdContext

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetSequence_name returns the sequence_name rule contexts.
	GetSequence_name() IIdContext

	// SetDatabase_name sets the database_name rule contexts.
	SetDatabase_name(IIdContext)

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetSequence_name sets the sequence_name rule contexts.
	SetSequence_name(IIdContext)

	// IsDrop_sequenceContext differentiates from other interfaces.
	IsDrop_sequenceContext()
}

IDrop_sequenceContext is an interface to support dynamic dispatch.

type IDrop_server_auditContext

type IDrop_server_auditContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAudit_name returns the audit_name rule contexts.
	GetAudit_name() IIdContext

	// SetAudit_name sets the audit_name rule contexts.
	SetAudit_name(IIdContext)

	// IsDrop_server_auditContext differentiates from other interfaces.
	IsDrop_server_auditContext()
}

IDrop_server_auditContext is an interface to support dynamic dispatch.

type IDrop_server_audit_specificationContext

type IDrop_server_audit_specificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAudit_specification_name returns the audit_specification_name rule contexts.
	GetAudit_specification_name() IIdContext

	// SetAudit_specification_name sets the audit_specification_name rule contexts.
	SetAudit_specification_name(IIdContext)

	// IsDrop_server_audit_specificationContext differentiates from other interfaces.
	IsDrop_server_audit_specificationContext()
}

IDrop_server_audit_specificationContext is an interface to support dynamic dispatch.

type IDrop_server_roleContext

type IDrop_server_roleContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRole_name returns the role_name rule contexts.
	GetRole_name() IIdContext

	// SetRole_name sets the role_name rule contexts.
	SetRole_name(IIdContext)

	// IsDrop_server_roleContext differentiates from other interfaces.
	IsDrop_server_roleContext()
}

IDrop_server_roleContext is an interface to support dynamic dispatch.

type IDrop_serviceContext

type IDrop_serviceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDropped_service_name returns the dropped_service_name rule contexts.
	GetDropped_service_name() IIdContext

	// SetDropped_service_name sets the dropped_service_name rule contexts.
	SetDropped_service_name(IIdContext)

	// IsDrop_serviceContext differentiates from other interfaces.
	IsDrop_serviceContext()
}

IDrop_serviceContext is an interface to support dynamic dispatch.

type IDrop_signatureContext

type IDrop_signatureContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetModule_name returns the module_name rule contexts.
	GetModule_name() IIdContext

	// GetCert_name returns the cert_name rule contexts.
	GetCert_name() IIdContext

	// GetAsym_key_name returns the Asym_key_name rule contexts.
	GetAsym_key_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetModule_name sets the module_name rule contexts.
	SetModule_name(IIdContext)

	// SetCert_name sets the cert_name rule contexts.
	SetCert_name(IIdContext)

	// SetAsym_key_name sets the Asym_key_name rule contexts.
	SetAsym_key_name(IIdContext)

	// IsDrop_signatureContext differentiates from other interfaces.
	IsDrop_signatureContext()
}

IDrop_signatureContext is an interface to support dynamic dispatch.

type IDrop_statisticsContext

type IDrop_statisticsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetName returns the name rule contexts.
	GetName() IIdContext

	// SetName sets the name rule contexts.
	SetName(IIdContext)

	// IsDrop_statisticsContext differentiates from other interfaces.
	IsDrop_statisticsContext()
}

IDrop_statisticsContext is an interface to support dynamic dispatch.

type IDrop_statistics_name_azure_dw_and_pdwContext

type IDrop_statistics_name_azure_dw_and_pdwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetObject_name returns the object_name rule contexts.
	GetObject_name() IIdContext

	// GetStatistics_name returns the statistics_name rule contexts.
	GetStatistics_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetObject_name sets the object_name rule contexts.
	SetObject_name(IIdContext)

	// SetStatistics_name sets the statistics_name rule contexts.
	SetStatistics_name(IIdContext)

	// IsDrop_statistics_name_azure_dw_and_pdwContext differentiates from other interfaces.
	IsDrop_statistics_name_azure_dw_and_pdwContext()
}

IDrop_statistics_name_azure_dw_and_pdwContext is an interface to support dynamic dispatch.

type IDrop_symmetric_keyContext

type IDrop_symmetric_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSymmetric_key_name returns the symmetric_key_name rule contexts.
	GetSymmetric_key_name() IIdContext

	// SetSymmetric_key_name sets the symmetric_key_name rule contexts.
	SetSymmetric_key_name(IIdContext)

	// IsDrop_symmetric_keyContext differentiates from other interfaces.
	IsDrop_symmetric_keyContext()
}

IDrop_symmetric_keyContext is an interface to support dynamic dispatch.

type IDrop_synonymContext

type IDrop_synonymContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetSynonym_name returns the synonym_name rule contexts.
	GetSynonym_name() IIdContext

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetSynonym_name sets the synonym_name rule contexts.
	SetSynonym_name(IIdContext)

	// IsDrop_synonymContext differentiates from other interfaces.
	IsDrop_synonymContext()
}

IDrop_synonymContext is an interface to support dynamic dispatch.

type IDrop_tableContext

type IDrop_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDrop_tableContext differentiates from other interfaces.
	IsDrop_tableContext()
}

IDrop_tableContext is an interface to support dynamic dispatch.

type IDrop_triggerContext

type IDrop_triggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDrop_triggerContext differentiates from other interfaces.
	IsDrop_triggerContext()
}

IDrop_triggerContext is an interface to support dynamic dispatch.

type IDrop_typeContext

type IDrop_typeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetName returns the name rule contexts.
	GetName() ISimple_nameContext

	// SetName sets the name rule contexts.
	SetName(ISimple_nameContext)

	// IsDrop_typeContext differentiates from other interfaces.
	IsDrop_typeContext()
}

IDrop_typeContext is an interface to support dynamic dispatch.

type IDrop_userContext

type IDrop_userContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetUser_name returns the user_name rule contexts.
	GetUser_name() IIdContext

	// SetUser_name sets the user_name rule contexts.
	SetUser_name(IIdContext)

	// IsDrop_userContext differentiates from other interfaces.
	IsDrop_userContext()
}

IDrop_userContext is an interface to support dynamic dispatch.

type IDrop_viewContext

type IDrop_viewContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsDrop_viewContext differentiates from other interfaces.
	IsDrop_viewContext()
}

IDrop_viewContext is an interface to support dynamic dispatch.

type IDrop_workload_groupContext

type IDrop_workload_groupContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetGroup_name returns the group_name rule contexts.
	GetGroup_name() IIdContext

	// SetGroup_name sets the group_name rule contexts.
	SetGroup_name(IIdContext)

	// IsDrop_workload_groupContext differentiates from other interfaces.
	IsDrop_workload_groupContext()
}

IDrop_workload_groupContext is an interface to support dynamic dispatch.

type IDrop_xml_schema_collectionContext

type IDrop_xml_schema_collectionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRelational_schema returns the relational_schema rule contexts.
	GetRelational_schema() IIdContext

	// GetSql_identifier returns the sql_identifier rule contexts.
	GetSql_identifier() IIdContext

	// SetRelational_schema sets the relational_schema rule contexts.
	SetRelational_schema(IIdContext)

	// SetSql_identifier sets the sql_identifier rule contexts.
	SetSql_identifier(IIdContext)

	// IsDrop_xml_schema_collectionContext differentiates from other interfaces.
	IsDrop_xml_schema_collectionContext()
}

IDrop_xml_schema_collectionContext is an interface to support dynamic dispatch.

type IEmpty_statementContext

type IEmpty_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEmpty_statementContext differentiates from other interfaces.
	IsEmpty_statementContext()
}

IEmpty_statementContext is an interface to support dynamic dispatch.

type IEnable_triggerContext

type IEnable_triggerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetTrigger_name returns the trigger_name rule contexts.
	GetTrigger_name() IIdContext

	// GetSchema_id returns the schema_id rule contexts.
	GetSchema_id() IIdContext

	// GetObject_name returns the object_name rule contexts.
	GetObject_name() IIdContext

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetTrigger_name sets the trigger_name rule contexts.
	SetTrigger_name(IIdContext)

	// SetSchema_id sets the schema_id rule contexts.
	SetSchema_id(IIdContext)

	// SetObject_name sets the object_name rule contexts.
	SetObject_name(IIdContext)

	// IsEnable_triggerContext differentiates from other interfaces.
	IsEnable_triggerContext()
}

IEnable_triggerContext is an interface to support dynamic dispatch.

type IEncryption_mechanismContext

type IEncryption_mechanismContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCertificate_name returns the certificate_name rule contexts.
	GetCertificate_name() IIdContext

	// GetAsym_key_name returns the asym_key_name rule contexts.
	GetAsym_key_name() IIdContext

	// GetDecrypting_Key_name returns the decrypting_Key_name rule contexts.
	GetDecrypting_Key_name() IIdContext

	// SetCertificate_name sets the certificate_name rule contexts.
	SetCertificate_name(IIdContext)

	// SetAsym_key_name sets the asym_key_name rule contexts.
	SetAsym_key_name(IIdContext)

	// SetDecrypting_Key_name sets the decrypting_Key_name rule contexts.
	SetDecrypting_Key_name(IIdContext)

	// IsEncryption_mechanismContext differentiates from other interfaces.
	IsEncryption_mechanismContext()
}

IEncryption_mechanismContext is an interface to support dynamic dispatch.

type IEnd_conversationContext

type IEnd_conversationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetConversation_handle returns the conversation_handle token.
	GetConversation_handle() antlr.Token

	// GetFaliure_code returns the faliure_code token.
	GetFaliure_code() antlr.Token

	// GetFailure_text returns the failure_text token.
	GetFailure_text() antlr.Token

	// SetConversation_handle sets the conversation_handle token.
	SetConversation_handle(antlr.Token)

	// SetFaliure_code sets the faliure_code token.
	SetFaliure_code(antlr.Token)

	// SetFailure_text sets the failure_text token.
	SetFailure_text(antlr.Token)

	// IsEnd_conversationContext differentiates from other interfaces.
	IsEnd_conversationContext()
}

IEnd_conversationContext is an interface to support dynamic dispatch.

type IEntity_nameContext

type IEntity_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetServer returns the server rule contexts.
	GetServer() IIdContext

	// GetDatabase returns the database rule contexts.
	GetDatabase() IIdContext

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetTable returns the table rule contexts.
	GetTable() IIdContext

	// SetServer sets the server rule contexts.
	SetServer(IIdContext)

	// SetDatabase sets the database rule contexts.
	SetDatabase(IIdContext)

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetTable sets the table rule contexts.
	SetTable(IIdContext)

	// IsEntity_nameContext differentiates from other interfaces.
	IsEntity_nameContext()
}

IEntity_nameContext is an interface to support dynamic dispatch.

type IEntity_name_for_azure_dwContext

type IEntity_name_for_azure_dwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetObject_name returns the object_name rule contexts.
	GetObject_name() IIdContext

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetObject_name sets the object_name rule contexts.
	SetObject_name(IIdContext)

	// IsEntity_name_for_azure_dwContext differentiates from other interfaces.
	IsEntity_name_for_azure_dwContext()
}

IEntity_name_for_azure_dwContext is an interface to support dynamic dispatch.

type IEntity_name_for_parallel_dwContext

type IEntity_name_for_parallel_dwContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema_database returns the schema_database rule contexts.
	GetSchema_database() IIdContext

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetObject_name returns the object_name rule contexts.
	GetObject_name() IIdContext

	// SetSchema_database sets the schema_database rule contexts.
	SetSchema_database(IIdContext)

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetObject_name sets the object_name rule contexts.
	SetObject_name(IIdContext)

	// IsEntity_name_for_parallel_dwContext differentiates from other interfaces.
	IsEntity_name_for_parallel_dwContext()
}

IEntity_name_for_parallel_dwContext is an interface to support dynamic dispatch.

type IEntity_toContext

type IEntity_toContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEntity_toContext differentiates from other interfaces.
	IsEntity_toContext()
}

IEntity_toContext is an interface to support dynamic dispatch.

type IEvent_session_predicate_expressionContext

type IEvent_session_predicate_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEvent_session_predicate_expressionContext differentiates from other interfaces.
	IsEvent_session_predicate_expressionContext()
}

IEvent_session_predicate_expressionContext is an interface to support dynamic dispatch.

type IEvent_session_predicate_factorContext

type IEvent_session_predicate_factorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEvent_session_predicate_factorContext differentiates from other interfaces.
	IsEvent_session_predicate_factorContext()
}

IEvent_session_predicate_factorContext is an interface to support dynamic dispatch.

type IEvent_session_predicate_leafContext

type IEvent_session_predicate_leafContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetEvent_field_name returns the event_field_name rule contexts.
	GetEvent_field_name() IIdContext

	// GetEvent_module_guid returns the event_module_guid rule contexts.
	GetEvent_module_guid() IIdContext

	// GetEvent_package_name returns the event_package_name rule contexts.
	GetEvent_package_name() IIdContext

	// GetPredicate_source_name returns the predicate_source_name rule contexts.
	GetPredicate_source_name() IIdContext

	// GetPredicate_compare_name returns the predicate_compare_name rule contexts.
	GetPredicate_compare_name() IIdContext

	// SetEvent_field_name sets the event_field_name rule contexts.
	SetEvent_field_name(IIdContext)

	// SetEvent_module_guid sets the event_module_guid rule contexts.
	SetEvent_module_guid(IIdContext)

	// SetEvent_package_name sets the event_package_name rule contexts.
	SetEvent_package_name(IIdContext)

	// SetPredicate_source_name sets the predicate_source_name rule contexts.
	SetPredicate_source_name(IIdContext)

	// SetPredicate_compare_name sets the predicate_compare_name rule contexts.
	SetPredicate_compare_name(IIdContext)

	// IsEvent_session_predicate_leafContext differentiates from other interfaces.
	IsEvent_session_predicate_leafContext()
}

IEvent_session_predicate_leafContext is an interface to support dynamic dispatch.

type IExecute_bodyContext

type IExecute_bodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetReturn_status returns the return_status token.
	GetReturn_status() antlr.Token

	// SetReturn_status sets the return_status token.
	SetReturn_status(antlr.Token)

	// IsExecute_bodyContext differentiates from other interfaces.
	IsExecute_bodyContext()
}

IExecute_bodyContext is an interface to support dynamic dispatch.

type IExecute_clauseContext

type IExecute_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetClause returns the clause token.
	GetClause() antlr.Token

	// SetClause sets the clause token.
	SetClause(antlr.Token)

	// IsExecute_clauseContext differentiates from other interfaces.
	IsExecute_clauseContext()
}

IExecute_clauseContext is an interface to support dynamic dispatch.

type IExecute_statementContext

type IExecute_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExecute_statementContext differentiates from other interfaces.
	IsExecute_statementContext()
}

IExecute_statementContext is an interface to support dynamic dispatch.

type IExecute_statement_argContext

type IExecute_statement_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetParameter returns the parameter token.
	GetParameter() antlr.Token

	// SetParameter sets the parameter token.
	SetParameter(antlr.Token)

	// IsExecute_statement_argContext differentiates from other interfaces.
	IsExecute_statement_argContext()
}

IExecute_statement_argContext is an interface to support dynamic dispatch.

type IExecute_var_stringContext

type IExecute_var_stringContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExecute_var_stringContext differentiates from other interfaces.
	IsExecute_var_stringContext()
}

IExecute_var_stringContext is an interface to support dynamic dispatch.

type IExist_methodContext

type IExist_methodContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetXquery returns the xquery token.
	GetXquery() antlr.Token

	// SetXquery sets the xquery token.
	SetXquery(antlr.Token)

	// IsExist_methodContext differentiates from other interfaces.
	IsExist_methodContext()
}

IExist_methodContext is an interface to support dynamic dispatch.

type IExisting_keysContext

type IExisting_keysContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPath_to_file returns the path_to_file token.
	GetPath_to_file() antlr.Token

	// SetPath_to_file sets the path_to_file token.
	SetPath_to_file(antlr.Token)

	// GetAssembly_name returns the assembly_name rule contexts.
	GetAssembly_name() IIdContext

	// SetAssembly_name sets the assembly_name rule contexts.
	SetAssembly_name(IIdContext)

	// IsExisting_keysContext differentiates from other interfaces.
	IsExisting_keysContext()
}

IExisting_keysContext is an interface to support dynamic dispatch.

type IExpressionContext

type IExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOp returns the op token.
	GetOp() antlr.Token

	// SetOp sets the op token.
	SetOp(antlr.Token)

	// IsExpressionContext differentiates from other interfaces.
	IsExpressionContext()
}

IExpressionContext is an interface to support dynamic dispatch.

type IExpression_elemContext

type IExpression_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetEq returns the eq token.
	GetEq() antlr.Token

	// SetEq sets the eq token.
	SetEq(antlr.Token)

	// IsExpression_elemContext differentiates from other interfaces.
	IsExpression_elemContext()
}

IExpression_elemContext is an interface to support dynamic dispatch.

type IExpression_listContext

type IExpression_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpression_listContext differentiates from other interfaces.
	IsExpression_listContext()
}

IExpression_listContext is an interface to support dynamic dispatch.

type IExternal_access_optionContext

type IExternal_access_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExternal_access_optionContext differentiates from other interfaces.
	IsExternal_access_optionContext()
}

IExternal_access_optionContext is an interface to support dynamic dispatch.

type IFFContext

type IFFContext struct {
	*Function_callContext
}

func NewIFFContext

func NewIFFContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *IFFContext

func (*IFFContext) AllCOMMA

func (s *IFFContext) AllCOMMA() []antlr.TerminalNode

func (*IFFContext) AllExpression

func (s *IFFContext) AllExpression() []IExpressionContext

func (*IFFContext) COMMA

func (s *IFFContext) COMMA(i int) antlr.TerminalNode

func (*IFFContext) EnterRule

func (s *IFFContext) EnterRule(listener antlr.ParseTreeListener)

func (*IFFContext) ExitRule

func (s *IFFContext) ExitRule(listener antlr.ParseTreeListener)

func (*IFFContext) Expression

func (s *IFFContext) Expression(i int) IExpressionContext

func (*IFFContext) GetRuleContext

func (s *IFFContext) GetRuleContext() antlr.RuleContext

func (*IFFContext) IIF

func (s *IFFContext) IIF() antlr.TerminalNode

func (*IFFContext) LR_BRACKET

func (s *IFFContext) LR_BRACKET() antlr.TerminalNode

func (*IFFContext) RR_BRACKET

func (s *IFFContext) RR_BRACKET() antlr.TerminalNode

func (*IFFContext) Search_condition

func (s *IFFContext) Search_condition() ISearch_conditionContext

type IFetch_cursorContext

type IFetch_cursorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFetch_cursorContext differentiates from other interfaces.
	IsFetch_cursorContext()
}

IFetch_cursorContext is an interface to support dynamic dispatch.

type IFile_directory_path_separatorContext

type IFile_directory_path_separatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFile_directory_path_separatorContext differentiates from other interfaces.
	IsFile_directory_path_separatorContext()
}

IFile_directory_path_separatorContext is an interface to support dynamic dispatch.

type IFile_groupContext

type IFile_groupContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFile_groupContext differentiates from other interfaces.
	IsFile_groupContext()
}

IFile_groupContext is an interface to support dynamic dispatch.

type IFile_pathContext

type IFile_pathContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFile_pathContext differentiates from other interfaces.
	IsFile_pathContext()
}

IFile_pathContext is an interface to support dynamic dispatch.

type IFile_sizeContext

type IFile_sizeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFile_sizeContext differentiates from other interfaces.
	IsFile_sizeContext()
}

IFile_sizeContext is an interface to support dynamic dispatch.

type IFile_specContext

type IFile_specContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetFile returns the file token.
	GetFile() antlr.Token

	// SetFile sets the file token.
	SetFile(antlr.Token)

	// IsFile_specContext differentiates from other interfaces.
	IsFile_specContext()
}

IFile_specContext is an interface to support dynamic dispatch.

type IFor_clauseContext

type IFor_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFor_clauseContext differentiates from other interfaces.
	IsFor_clauseContext()
}

IFor_clauseContext is an interface to support dynamic dispatch.

type IFull_column_nameContext

type IFull_column_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetColumn_name returns the column_name rule contexts.
	GetColumn_name() IIdContext

	// SetColumn_name sets the column_name rule contexts.
	SetColumn_name(IIdContext)

	// IsFull_column_nameContext differentiates from other interfaces.
	IsFull_column_nameContext()
}

IFull_column_nameContext is an interface to support dynamic dispatch.

type IFull_column_name_listContext

type IFull_column_name_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFull_column_name_listContext differentiates from other interfaces.
	IsFull_column_name_listContext()
}

IFull_column_name_listContext is an interface to support dynamic dispatch.

type IFull_table_nameContext

type IFull_table_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetServer returns the server rule contexts.
	GetServer() IIdContext

	// GetDatabase returns the database rule contexts.
	GetDatabase() IIdContext

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetTable returns the table rule contexts.
	GetTable() IIdContext

	// SetServer sets the server rule contexts.
	SetServer(IIdContext)

	// SetDatabase sets the database rule contexts.
	SetDatabase(IIdContext)

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetTable sets the table rule contexts.
	SetTable(IIdContext)

	// IsFull_table_nameContext differentiates from other interfaces.
	IsFull_table_nameContext()
}

IFull_table_nameContext is an interface to support dynamic dispatch.

type IFunc_body_returns_scalarContext

type IFunc_body_returns_scalarContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetRet returns the ret rule contexts.
	GetRet() IExpressionContext

	// SetRet sets the ret rule contexts.
	SetRet(IExpressionContext)

	// IsFunc_body_returns_scalarContext differentiates from other interfaces.
	IsFunc_body_returns_scalarContext()
}

IFunc_body_returns_scalarContext is an interface to support dynamic dispatch.

type IFunc_body_returns_selectContext

type IFunc_body_returns_selectContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunc_body_returns_selectContext differentiates from other interfaces.
	IsFunc_body_returns_selectContext()
}

IFunc_body_returns_selectContext is an interface to support dynamic dispatch.

type IFunc_body_returns_tableContext

type IFunc_body_returns_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunc_body_returns_tableContext differentiates from other interfaces.
	IsFunc_body_returns_tableContext()
}

IFunc_body_returns_tableContext is an interface to support dynamic dispatch.

type IFunc_proc_name_database_schemaContext

type IFunc_proc_name_database_schemaContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDatabase returns the database rule contexts.
	GetDatabase() IIdContext

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetProcedure returns the procedure rule contexts.
	GetProcedure() IIdContext

	// SetDatabase sets the database rule contexts.
	SetDatabase(IIdContext)

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetProcedure sets the procedure rule contexts.
	SetProcedure(IIdContext)

	// IsFunc_proc_name_database_schemaContext differentiates from other interfaces.
	IsFunc_proc_name_database_schemaContext()
}

IFunc_proc_name_database_schemaContext is an interface to support dynamic dispatch.

type IFunc_proc_name_schemaContext

type IFunc_proc_name_schemaContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetProcedure returns the procedure rule contexts.
	GetProcedure() IIdContext

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetProcedure sets the procedure rule contexts.
	SetProcedure(IIdContext)

	// IsFunc_proc_name_schemaContext differentiates from other interfaces.
	IsFunc_proc_name_schemaContext()
}

IFunc_proc_name_schemaContext is an interface to support dynamic dispatch.

type IFunc_proc_name_server_database_schemaContext

type IFunc_proc_name_server_database_schemaContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetServer returns the server rule contexts.
	GetServer() IIdContext

	// GetDatabase returns the database rule contexts.
	GetDatabase() IIdContext

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetProcedure returns the procedure rule contexts.
	GetProcedure() IIdContext

	// SetServer sets the server rule contexts.
	SetServer(IIdContext)

	// SetDatabase sets the database rule contexts.
	SetDatabase(IIdContext)

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetProcedure sets the procedure rule contexts.
	SetProcedure(IIdContext)

	// IsFunc_proc_name_server_database_schemaContext differentiates from other interfaces.
	IsFunc_proc_name_server_database_schemaContext()
}

IFunc_proc_name_server_database_schemaContext is an interface to support dynamic dispatch.

type IFunction_callContext

type IFunction_callContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunction_callContext differentiates from other interfaces.
	IsFunction_callContext()
}

IFunction_callContext is an interface to support dynamic dispatch.

type IFunction_optionContext

type IFunction_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunction_optionContext differentiates from other interfaces.
	IsFunction_optionContext()
}

IFunction_optionContext is an interface to support dynamic dispatch.

type IGenerate_new_keysContext

type IGenerate_new_keysContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// GetCertificate_subject_name returns the certificate_subject_name token.
	GetCertificate_subject_name() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// SetCertificate_subject_name sets the certificate_subject_name token.
	SetCertificate_subject_name(antlr.Token)

	// IsGenerate_new_keysContext differentiates from other interfaces.
	IsGenerate_new_keysContext()
}

IGenerate_new_keysContext is an interface to support dynamic dispatch.

type IGet_conversationContext

type IGet_conversationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetConversation_group_id returns the conversation_group_id token.
	GetConversation_group_id() antlr.Token

	// SetConversation_group_id sets the conversation_group_id token.
	SetConversation_group_id(antlr.Token)

	// GetQueue returns the queue rule contexts.
	GetQueue() IQueue_idContext

	// SetQueue sets the queue rule contexts.
	SetQueue(IQueue_idContext)

	// IsGet_conversationContext differentiates from other interfaces.
	IsGet_conversationContext()
}

IGet_conversationContext is an interface to support dynamic dispatch.

type IGo_statementContext

type IGo_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCount returns the count token.
	GetCount() antlr.Token

	// SetCount sets the count token.
	SetCount(antlr.Token)

	// IsGo_statementContext differentiates from other interfaces.
	IsGo_statementContext()
}

IGo_statementContext is an interface to support dynamic dispatch.

type IGoto_statementContext

type IGoto_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGoto_statementContext differentiates from other interfaces.
	IsGoto_statementContext()
}

IGoto_statementContext is an interface to support dynamic dispatch.

type IGrant_permissionContext

type IGrant_permissionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGrant_permissionContext differentiates from other interfaces.
	IsGrant_permissionContext()
}

IGrant_permissionContext is an interface to support dynamic dispatch.

type IGroup_by_itemContext

type IGroup_by_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsGroup_by_itemContext differentiates from other interfaces.
	IsGroup_by_itemContext()
}

IGroup_by_itemContext is an interface to support dynamic dispatch.

type IHadr_optionsContext

type IHadr_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetAvailability_group_name returns the availability_group_name rule contexts.
	GetAvailability_group_name() IIdContext

	// SetAvailability_group_name sets the availability_group_name rule contexts.
	SetAvailability_group_name(IIdContext)

	// IsHadr_optionsContext differentiates from other interfaces.
	IsHadr_optionsContext()
}

IHadr_optionsContext is an interface to support dynamic dispatch.

type IHostContext

type IHostContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsHostContext differentiates from other interfaces.
	IsHostContext()
}

IHostContext is an interface to support dynamic dispatch.

type IIdContext

type IIdContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIdContext differentiates from other interfaces.
	IsIdContext()
}

IIdContext is an interface to support dynamic dispatch.

type IIf_statementContext

type IIf_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIf_statementContext differentiates from other interfaces.
	IsIf_statementContext()
}

IIf_statementContext is an interface to support dynamic dispatch.

type IIndex_optionContext

type IIndex_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndex_optionContext differentiates from other interfaces.
	IsIndex_optionContext()
}

IIndex_optionContext is an interface to support dynamic dispatch.

type IIndex_optionsContext

type IIndex_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndex_optionsContext differentiates from other interfaces.
	IsIndex_optionsContext()
}

IIndex_optionsContext is an interface to support dynamic dispatch.

type IIndex_valueContext

type IIndex_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIndex_valueContext differentiates from other interfaces.
	IsIndex_valueContext()
}

IIndex_valueContext is an interface to support dynamic dispatch.

type IInsert_statementContext

type IInsert_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInsert_statementContext differentiates from other interfaces.
	IsInsert_statementContext()
}

IInsert_statementContext is an interface to support dynamic dispatch.

type IInsert_statement_valueContext

type IInsert_statement_valueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInsert_statement_valueContext differentiates from other interfaces.
	IsInsert_statement_valueContext()
}

IInsert_statement_valueContext is an interface to support dynamic dispatch.

type IInsert_with_table_hintsContext

type IInsert_with_table_hintsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInsert_with_table_hintsContext differentiates from other interfaces.
	IsInsert_with_table_hintsContext()
}

IInsert_with_table_hintsContext is an interface to support dynamic dispatch.

type IJoin_partContext

type IJoin_partContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetJoin_type returns the join_type token.
	GetJoin_type() antlr.Token

	// GetJoin_hint returns the join_hint token.
	GetJoin_hint() antlr.Token

	// SetJoin_type sets the join_type token.
	SetJoin_type(antlr.Token)

	// SetJoin_hint sets the join_hint token.
	SetJoin_hint(antlr.Token)

	// IsJoin_partContext differentiates from other interfaces.
	IsJoin_partContext()
}

IJoin_partContext is an interface to support dynamic dispatch.

type IKey_optionsContext

type IKey_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPass_phrase returns the pass_phrase token.
	GetPass_phrase() antlr.Token

	// GetIdentity_phrase returns the identity_phrase token.
	GetIdentity_phrase() antlr.Token

	// GetKey_name_in_provider returns the key_name_in_provider token.
	GetKey_name_in_provider() antlr.Token

	// SetPass_phrase sets the pass_phrase token.
	SetPass_phrase(antlr.Token)

	// SetIdentity_phrase sets the identity_phrase token.
	SetIdentity_phrase(antlr.Token)

	// SetKey_name_in_provider sets the key_name_in_provider token.
	SetKey_name_in_provider(antlr.Token)

	// IsKey_optionsContext differentiates from other interfaces.
	IsKey_optionsContext()
}

IKey_optionsContext is an interface to support dynamic dispatch.

type ILocal_driveContext

type ILocal_driveContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLocal_driveContext differentiates from other interfaces.
	IsLocal_driveContext()
}

ILocal_driveContext is an interface to support dynamic dispatch.

type ILocal_fileContext

type ILocal_fileContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLocal_fileContext differentiates from other interfaces.
	IsLocal_fileContext()
}

ILocal_fileContext is an interface to support dynamic dispatch.

type ILock_tableContext

type ILock_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSeconds returns the seconds token.
	GetSeconds() antlr.Token

	// SetSeconds sets the seconds token.
	SetSeconds(antlr.Token)

	// IsLock_tableContext differentiates from other interfaces.
	IsLock_tableContext()
}

ILock_tableContext is an interface to support dynamic dispatch.

type IMaterialized_column_definitionContext

type IMaterialized_column_definitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMaterialized_column_definitionContext differentiates from other interfaces.
	IsMaterialized_column_definitionContext()
}

IMaterialized_column_definitionContext is an interface to support dynamic dispatch.

type IMerge_matchedContext

type IMerge_matchedContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMerge_matchedContext differentiates from other interfaces.
	IsMerge_matchedContext()
}

IMerge_matchedContext is an interface to support dynamic dispatch.

type IMerge_not_matchedContext

type IMerge_not_matchedContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMerge_not_matchedContext differentiates from other interfaces.
	IsMerge_not_matchedContext()
}

IMerge_not_matchedContext is an interface to support dynamic dispatch.

type IMerge_statementContext

type IMerge_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMerge_statementContext differentiates from other interfaces.
	IsMerge_statementContext()
}

IMerge_statementContext is an interface to support dynamic dispatch.

type IMessage_statementContext

type IMessage_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMessage_type_name returns the message_type_name rule contexts.
	GetMessage_type_name() IIdContext

	// GetOwner_name returns the owner_name rule contexts.
	GetOwner_name() IIdContext

	// GetSchema_collection_name returns the schema_collection_name rule contexts.
	GetSchema_collection_name() IIdContext

	// SetMessage_type_name sets the message_type_name rule contexts.
	SetMessage_type_name(IIdContext)

	// SetOwner_name sets the owner_name rule contexts.
	SetOwner_name(IIdContext)

	// SetSchema_collection_name sets the schema_collection_name rule contexts.
	SetSchema_collection_name(IIdContext)

	// IsMessage_statementContext differentiates from other interfaces.
	IsMessage_statementContext()
}

IMessage_statementContext is an interface to support dynamic dispatch.

type IMirroring_host_port_seperatorContext

type IMirroring_host_port_seperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMirroring_host_port_seperatorContext differentiates from other interfaces.
	IsMirroring_host_port_seperatorContext()
}

IMirroring_host_port_seperatorContext is an interface to support dynamic dispatch.

type IMirroring_partnerContext

type IMirroring_partnerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMirroring_partnerContext differentiates from other interfaces.
	IsMirroring_partnerContext()
}

IMirroring_partnerContext is an interface to support dynamic dispatch.

type IMirroring_set_optionContext

type IMirroring_set_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMirroring_set_optionContext differentiates from other interfaces.
	IsMirroring_set_optionContext()
}

IMirroring_set_optionContext is an interface to support dynamic dispatch.

type IMirroring_witnessContext

type IMirroring_witnessContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMirroring_witnessContext differentiates from other interfaces.
	IsMirroring_witnessContext()
}

IMirroring_witnessContext is an interface to support dynamic dispatch.

type IMixed_page_allocation_optionContext

type IMixed_page_allocation_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMixed_page_allocation_optionContext differentiates from other interfaces.
	IsMixed_page_allocation_optionContext()
}

IMixed_page_allocation_optionContext is an interface to support dynamic dispatch.

type IModify_methodContext

type IModify_methodContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetXml_dml returns the xml_dml token.
	GetXml_dml() antlr.Token

	// SetXml_dml sets the xml_dml token.
	SetXml_dml(antlr.Token)

	// IsModify_methodContext differentiates from other interfaces.
	IsModify_methodContext()
}

IModify_methodContext is an interface to support dynamic dispatch.

type IMultiple_local_file_startContext

type IMultiple_local_file_startContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMultiple_local_file_startContext differentiates from other interfaces.
	IsMultiple_local_file_startContext()
}

IMultiple_local_file_startContext is an interface to support dynamic dispatch.

type IMultiple_local_filesContext

type IMultiple_local_filesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMultiple_local_filesContext differentiates from other interfaces.
	IsMultiple_local_filesContext()
}

IMultiple_local_filesContext is an interface to support dynamic dispatch.

type INetwork_computerContext

type INetwork_computerContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetComputer_name returns the computer_name rule contexts.
	GetComputer_name() IIdContext

	// SetComputer_name sets the computer_name rule contexts.
	SetComputer_name(IIdContext)

	// IsNetwork_computerContext differentiates from other interfaces.
	IsNetwork_computerContext()
}

INetwork_computerContext is an interface to support dynamic dispatch.

type INetwork_file_shareContext

type INetwork_file_shareContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNetwork_file_shareContext differentiates from other interfaces.
	IsNetwork_file_shareContext()
}

INetwork_file_shareContext is an interface to support dynamic dispatch.

type INetwork_file_startContext

type INetwork_file_startContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNetwork_file_startContext differentiates from other interfaces.
	IsNetwork_file_startContext()
}

INetwork_file_startContext is an interface to support dynamic dispatch.

type INodes_methodContext

type INodes_methodContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetXquery returns the xquery token.
	GetXquery() antlr.Token

	// SetXquery sets the xquery token.
	SetXquery(antlr.Token)

	// IsNodes_methodContext differentiates from other interfaces.
	IsNodes_methodContext()
}

INodes_methodContext is an interface to support dynamic dispatch.

type INull_notnullContext

type INull_notnullContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNull_notnullContext differentiates from other interfaces.
	IsNull_notnullContext()
}

INull_notnullContext is an interface to support dynamic dispatch.

type INull_or_defaultContext

type INull_or_defaultContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNull_or_defaultContext differentiates from other interfaces.
	IsNull_or_defaultContext()
}

INull_or_defaultContext is an interface to support dynamic dispatch.

type IOn_deleteContext

type IOn_deleteContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOn_deleteContext differentiates from other interfaces.
	IsOn_deleteContext()
}

IOn_deleteContext is an interface to support dynamic dispatch.

type IOn_offContext

type IOn_offContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOn_offContext differentiates from other interfaces.
	IsOn_offContext()
}

IOn_offContext is an interface to support dynamic dispatch.

type IOn_updateContext

type IOn_updateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOn_updateContext differentiates from other interfaces.
	IsOn_updateContext()
}

IOn_updateContext is an interface to support dynamic dispatch.

type IOpen_keyContext

type IOpen_keyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// GetKey_name returns the key_name rule contexts.
	GetKey_name() IIdContext

	// SetKey_name sets the key_name rule contexts.
	SetKey_name(IIdContext)

	// IsOpen_keyContext differentiates from other interfaces.
	IsOpen_keyContext()
}

IOpen_keyContext is an interface to support dynamic dispatch.

type IOpen_xmlContext

type IOpen_xmlContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOpen_xmlContext differentiates from other interfaces.
	IsOpen_xmlContext()
}

IOpen_xmlContext is an interface to support dynamic dispatch.

type IOpendatasourceContext

type IOpendatasourceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetProvider returns the provider token.
	GetProvider() antlr.Token

	// GetInit returns the init token.
	GetInit() antlr.Token

	// SetProvider sets the provider token.
	SetProvider(antlr.Token)

	// SetInit sets the init token.
	SetInit(antlr.Token)

	// GetDatabase returns the database rule contexts.
	GetDatabase() IIdContext

	// GetScheme returns the scheme rule contexts.
	GetScheme() IIdContext

	// GetTable returns the table rule contexts.
	GetTable() IIdContext

	// SetDatabase sets the database rule contexts.
	SetDatabase(IIdContext)

	// SetScheme sets the scheme rule contexts.
	SetScheme(IIdContext)

	// SetTable sets the table rule contexts.
	SetTable(IIdContext)

	// IsOpendatasourceContext differentiates from other interfaces.
	IsOpendatasourceContext()
}

IOpendatasourceContext is an interface to support dynamic dispatch.

type IOpenqueryContext

type IOpenqueryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetQuery returns the query token.
	GetQuery() antlr.Token

	// SetQuery sets the query token.
	SetQuery(antlr.Token)

	// GetLinked_server returns the linked_server rule contexts.
	GetLinked_server() IIdContext

	// SetLinked_server sets the linked_server rule contexts.
	SetLinked_server(IIdContext)

	// IsOpenqueryContext differentiates from other interfaces.
	IsOpenqueryContext()
}

IOpenqueryContext is an interface to support dynamic dispatch.

type IOptimize_for_argContext

type IOptimize_for_argContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOptimize_for_argContext differentiates from other interfaces.
	IsOptimize_for_argContext()
}

IOptimize_for_argContext is an interface to support dynamic dispatch.

type IOptionContext

type IOptionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetNumber_rows returns the number_rows token.
	GetNumber_rows() antlr.Token

	// GetNumber_of_processors returns the number_of_processors token.
	GetNumber_of_processors() antlr.Token

	// GetNumber_recursion returns the number_recursion token.
	GetNumber_recursion() antlr.Token

	// SetNumber_rows sets the number_rows token.
	SetNumber_rows(antlr.Token)

	// SetNumber_of_processors sets the number_of_processors token.
	SetNumber_of_processors(antlr.Token)

	// SetNumber_recursion sets the number_recursion token.
	SetNumber_recursion(antlr.Token)

	// IsOptionContext differentiates from other interfaces.
	IsOptionContext()
}

IOptionContext is an interface to support dynamic dispatch.

type IOption_clauseContext

type IOption_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOption_clauseContext differentiates from other interfaces.
	IsOption_clauseContext()
}

IOption_clauseContext is an interface to support dynamic dispatch.

type IOrder_by_clauseContext

type IOrder_by_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOrder_by_clauseContext differentiates from other interfaces.
	IsOrder_by_clauseContext()
}

IOrder_by_clauseContext is an interface to support dynamic dispatch.

type IOrder_by_expressionContext

type IOrder_by_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOrder_by_expressionContext differentiates from other interfaces.
	IsOrder_by_expressionContext()
}

IOrder_by_expressionContext is an interface to support dynamic dispatch.

type IOutput_clauseContext

type IOutput_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOutput_clauseContext differentiates from other interfaces.
	IsOutput_clauseContext()
}

IOutput_clauseContext is an interface to support dynamic dispatch.

type IOutput_column_nameContext

type IOutput_column_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOutput_column_nameContext differentiates from other interfaces.
	IsOutput_column_nameContext()
}

IOutput_column_nameContext is an interface to support dynamic dispatch.

type IOutput_dml_list_elemContext

type IOutput_dml_list_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOutput_dml_list_elemContext differentiates from other interfaces.
	IsOutput_dml_list_elemContext()
}

IOutput_dml_list_elemContext is an interface to support dynamic dispatch.

type IOver_clauseContext

type IOver_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsOver_clauseContext differentiates from other interfaces.
	IsOver_clauseContext()
}

IOver_clauseContext is an interface to support dynamic dispatch.

type IParameterization_optionContext

type IParameterization_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsParameterization_optionContext differentiates from other interfaces.
	IsParameterization_optionContext()
}

IParameterization_optionContext is an interface to support dynamic dispatch.

type IPartner_optionContext

type IPartner_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPartner_optionContext differentiates from other interfaces.
	IsPartner_optionContext()
}

IPartner_optionContext is an interface to support dynamic dispatch.

type IPartner_serverContext

type IPartner_serverContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPartner_serverContext differentiates from other interfaces.
	IsPartner_serverContext()
}

IPartner_serverContext is an interface to support dynamic dispatch.

type IPartner_server_tcp_prefixContext

type IPartner_server_tcp_prefixContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPartner_server_tcp_prefixContext differentiates from other interfaces.
	IsPartner_server_tcp_prefixContext()
}

IPartner_server_tcp_prefixContext is an interface to support dynamic dispatch.

type IPivot_clauseContext

type IPivot_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPivot_clauseContext differentiates from other interfaces.
	IsPivot_clauseContext()
}

IPivot_clauseContext is an interface to support dynamic dispatch.

type IPort_numberContext

type IPort_numberContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPort returns the port token.
	GetPort() antlr.Token

	// SetPort sets the port token.
	SetPort(antlr.Token)

	// IsPort_numberContext differentiates from other interfaces.
	IsPort_numberContext()
}

IPort_numberContext 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 IPrimitive_expressionContext

type IPrimitive_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrimitive_expressionContext differentiates from other interfaces.
	IsPrimitive_expressionContext()
}

IPrimitive_expressionContext is an interface to support dynamic dispatch.

type IPrint_statementContext

type IPrint_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPrint_statementContext differentiates from other interfaces.
	IsPrint_statementContext()
}

IPrint_statementContext is an interface to support dynamic dispatch.

type IPrivate_key_optionsContext

type IPrivate_key_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPath returns the path token.
	GetPath() antlr.Token

	// GetPassword returns the password token.
	GetPassword() antlr.Token

	// SetPath sets the path token.
	SetPath(antlr.Token)

	// SetPassword sets the password token.
	SetPassword(antlr.Token)

	// IsPrivate_key_optionsContext differentiates from other interfaces.
	IsPrivate_key_optionsContext()
}

IPrivate_key_optionsContext is an interface to support dynamic dispatch.

type IProcedure_optionContext

type IProcedure_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsProcedure_optionContext differentiates from other interfaces.
	IsProcedure_optionContext()
}

IProcedure_optionContext is an interface to support dynamic dispatch.

type IProcedure_paramContext

type IProcedure_paramContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDefault_val returns the default_val rule contexts.
	GetDefault_val() IDefault_valueContext

	// SetDefault_val sets the default_val rule contexts.
	SetDefault_val(IDefault_valueContext)

	// IsProcedure_paramContext differentiates from other interfaces.
	IsProcedure_paramContext()
}

IProcedure_paramContext is an interface to support dynamic dispatch.

type IQuery_expressionContext

type IQuery_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsQuery_expressionContext differentiates from other interfaces.
	IsQuery_expressionContext()
}

IQuery_expressionContext is an interface to support dynamic dispatch.

type IQuery_methodContext

type IQuery_methodContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetXquery returns the xquery token.
	GetXquery() antlr.Token

	// SetXquery sets the xquery token.
	SetXquery(antlr.Token)

	// IsQuery_methodContext differentiates from other interfaces.
	IsQuery_methodContext()
}

IQuery_methodContext is an interface to support dynamic dispatch.

type IQuery_specificationContext

type IQuery_specificationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetWhere returns the where rule contexts.
	GetWhere() ISearch_conditionContext

	// GetHaving returns the having rule contexts.
	GetHaving() ISearch_conditionContext

	// SetWhere sets the where rule contexts.
	SetWhere(ISearch_conditionContext)

	// SetHaving sets the having rule contexts.
	SetHaving(ISearch_conditionContext)

	// IsQuery_specificationContext differentiates from other interfaces.
	IsQuery_specificationContext()
}

IQuery_specificationContext is an interface to support dynamic dispatch.

type IQueue_actionContext

type IQueue_actionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsQueue_actionContext differentiates from other interfaces.
	IsQueue_actionContext()
}

IQueue_actionContext is an interface to support dynamic dispatch.

type IQueue_idContext

type IQueue_idContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDatabase_name returns the database_name rule contexts.
	GetDatabase_name() IIdContext

	// GetSchema_name returns the schema_name rule contexts.
	GetSchema_name() IIdContext

	// GetName returns the name rule contexts.
	GetName() IIdContext

	// SetDatabase_name sets the database_name rule contexts.
	SetDatabase_name(IIdContext)

	// SetSchema_name sets the schema_name rule contexts.
	SetSchema_name(IIdContext)

	// SetName sets the name rule contexts.
	SetName(IIdContext)

	// IsQueue_idContext differentiates from other interfaces.
	IsQueue_idContext()
}

IQueue_idContext is an interface to support dynamic dispatch.

type IQueue_rebuild_optionsContext

type IQueue_rebuild_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsQueue_rebuild_optionsContext differentiates from other interfaces.
	IsQueue_rebuild_optionsContext()
}

IQueue_rebuild_optionsContext is an interface to support dynamic dispatch.

type IQueue_settingsContext

type IQueue_settingsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMax_readers returns the max_readers token.
	GetMax_readers() antlr.Token

	// GetUser_name returns the user_name token.
	GetUser_name() antlr.Token

	// SetMax_readers sets the max_readers token.
	SetMax_readers(antlr.Token)

	// SetUser_name sets the user_name token.
	SetUser_name(antlr.Token)

	// IsQueue_settingsContext differentiates from other interfaces.
	IsQueue_settingsContext()
}

IQueue_settingsContext is an interface to support dynamic dispatch.

type IRaiseerror_statementContext

type IRaiseerror_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMsg returns the msg token.
	GetMsg() antlr.Token

	// GetFormatstring returns the formatstring token.
	GetFormatstring() antlr.Token

	// GetArgument returns the argument token.
	GetArgument() antlr.Token

	// SetMsg sets the msg token.
	SetMsg(antlr.Token)

	// SetFormatstring sets the formatstring token.
	SetFormatstring(antlr.Token)

	// SetArgument sets the argument token.
	SetArgument(antlr.Token)

	// GetSeverity returns the severity rule contexts.
	GetSeverity() IConstant_LOCAL_IDContext

	// GetState returns the state rule contexts.
	GetState() IConstant_LOCAL_IDContext

	// SetSeverity sets the severity rule contexts.
	SetSeverity(IConstant_LOCAL_IDContext)

	// SetState sets the state rule contexts.
	SetState(IConstant_LOCAL_IDContext)

	// IsRaiseerror_statementContext differentiates from other interfaces.
	IsRaiseerror_statementContext()
}

IRaiseerror_statementContext is an interface to support dynamic dispatch.

type IRanking_windowed_functionContext

type IRanking_windowed_functionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRanking_windowed_functionContext differentiates from other interfaces.
	IsRanking_windowed_functionContext()
}

IRanking_windowed_functionContext is an interface to support dynamic dispatch.

type IReceive_statementContext

type IReceive_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetTable_variable returns the table_variable rule contexts.
	GetTable_variable() IIdContext

	// GetWhere returns the where rule contexts.
	GetWhere() ISearch_conditionContext

	// SetTable_variable sets the table_variable rule contexts.
	SetTable_variable(IIdContext)

	// SetWhere sets the where rule contexts.
	SetWhere(ISearch_conditionContext)

	// IsReceive_statementContext differentiates from other interfaces.
	IsReceive_statementContext()
}

IReceive_statementContext is an interface to support dynamic dispatch.

type IRecovery_optionContext

type IRecovery_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRecovery_optionContext differentiates from other interfaces.
	IsRecovery_optionContext()
}

IRecovery_optionContext is an interface to support dynamic dispatch.

type IReturn_statementContext

type IReturn_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReturn_statementContext differentiates from other interfaces.
	IsReturn_statementContext()
}

IReturn_statementContext is an interface to support dynamic dispatch.

type IRow_or_range_clauseContext

type IRow_or_range_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRow_or_range_clauseContext differentiates from other interfaces.
	IsRow_or_range_clauseContext()
}

IRow_or_range_clauseContext is an interface to support dynamic dispatch.

type IRowset_functionContext

type IRowset_functionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetProvider_name returns the provider_name token.
	GetProvider_name() antlr.Token

	// GetConnectionString returns the connectionString token.
	GetConnectionString() antlr.Token

	// GetSql returns the sql token.
	GetSql() antlr.Token

	// GetData_file returns the data_file token.
	GetData_file() antlr.Token

	// SetProvider_name sets the provider_name token.
	SetProvider_name(antlr.Token)

	// SetConnectionString sets the connectionString token.
	SetConnectionString(antlr.Token)

	// SetSql sets the sql token.
	SetSql(antlr.Token)

	// SetData_file sets the data_file token.
	SetData_file(antlr.Token)

	// IsRowset_functionContext differentiates from other interfaces.
	IsRowset_functionContext()
}

IRowset_functionContext is an interface to support dynamic dispatch.

type IRowset_function_limitedContext

type IRowset_function_limitedContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRowset_function_limitedContext differentiates from other interfaces.
	IsRowset_function_limitedContext()
}

IRowset_function_limitedContext is an interface to support dynamic dispatch.

type ISNULLContext

type ISNULLContext struct {
	*Function_callContext
}

func NewISNULLContext

func NewISNULLContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ISNULLContext

func (*ISNULLContext) AllExpression

func (s *ISNULLContext) AllExpression() []IExpressionContext

func (*ISNULLContext) COMMA

func (s *ISNULLContext) COMMA() antlr.TerminalNode

func (*ISNULLContext) EnterRule

func (s *ISNULLContext) EnterRule(listener antlr.ParseTreeListener)

func (*ISNULLContext) ExitRule

func (s *ISNULLContext) ExitRule(listener antlr.ParseTreeListener)

func (*ISNULLContext) Expression

func (s *ISNULLContext) Expression(i int) IExpressionContext

func (*ISNULLContext) GetRuleContext

func (s *ISNULLContext) GetRuleContext() antlr.RuleContext

func (*ISNULLContext) ISNULL

func (s *ISNULLContext) ISNULL() antlr.TerminalNode

func (*ISNULLContext) LR_BRACKET

func (s *ISNULLContext) LR_BRACKET() antlr.TerminalNode

func (*ISNULLContext) RR_BRACKET

func (s *ISNULLContext) RR_BRACKET() antlr.TerminalNode

type IScalar_function_nameContext

type IScalar_function_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsScalar_function_nameContext differentiates from other interfaces.
	IsScalar_function_nameContext()
}

IScalar_function_nameContext is an interface to support dynamic dispatch.

type ISchema_declarationContext

type ISchema_declarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSchema_declarationContext differentiates from other interfaces.
	IsSchema_declarationContext()
}

ISchema_declarationContext is an interface to support dynamic dispatch.

type ISearch_conditionContext

type ISearch_conditionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSearch_conditionContext differentiates from other interfaces.
	IsSearch_conditionContext()
}

ISearch_conditionContext is an interface to support dynamic dispatch.

type ISearch_condition_andContext

type ISearch_condition_andContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSearch_condition_andContext differentiates from other interfaces.
	IsSearch_condition_andContext()
}

ISearch_condition_andContext is an interface to support dynamic dispatch.

type ISearch_condition_listContext

type ISearch_condition_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSearch_condition_listContext differentiates from other interfaces.
	IsSearch_condition_listContext()
}

ISearch_condition_listContext is an interface to support dynamic dispatch.

type ISearch_condition_notContext

type ISearch_condition_notContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSearch_condition_notContext differentiates from other interfaces.
	IsSearch_condition_notContext()
}

ISearch_condition_notContext is an interface to support dynamic dispatch.

type ISecurity_statementContext

type ISecurity_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOn_id returns the on_id rule contexts.
	GetOn_id() ITable_nameContext

	// Get_id returns the _id rule contexts.
	Get_id() IIdContext

	// GetAs_principal returns the as_principal rule contexts.
	GetAs_principal() IIdContext

	// SetOn_id sets the on_id rule contexts.
	SetOn_id(ITable_nameContext)

	// Set_id sets the _id rule contexts.
	Set_id(IIdContext)

	// SetAs_principal sets the as_principal rule contexts.
	SetAs_principal(IIdContext)

	// GetTo_principal returns the to_principal rule context list.
	GetTo_principal() []IIdContext

	// SetTo_principal sets the to_principal rule context list.
	SetTo_principal([]IIdContext)

	// IsSecurity_statementContext differentiates from other interfaces.
	IsSecurity_statementContext()
}

ISecurity_statementContext is an interface to support dynamic dispatch.

type ISelect_listContext

type ISelect_listContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelect_listContext differentiates from other interfaces.
	IsSelect_listContext()
}

ISelect_listContext is an interface to support dynamic dispatch.

type ISelect_list_elemContext

type ISelect_list_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelect_list_elemContext differentiates from other interfaces.
	IsSelect_list_elemContext()
}

ISelect_list_elemContext is an interface to support dynamic dispatch.

type ISelect_statementContext

type ISelect_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSelect_statementContext differentiates from other interfaces.
	IsSelect_statementContext()
}

ISelect_statementContext is an interface to support dynamic dispatch.

type ISend_conversationContext

type ISend_conversationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetConversation_handle returns the conversation_handle token.
	GetConversation_handle() antlr.Token

	// GetMessage_body_expression returns the message_body_expression token.
	GetMessage_body_expression() antlr.Token

	// SetConversation_handle sets the conversation_handle token.
	SetConversation_handle(antlr.Token)

	// SetMessage_body_expression sets the message_body_expression token.
	SetMessage_body_expression(antlr.Token)

	// GetMessage_type_name returns the message_type_name rule contexts.
	GetMessage_type_name() IExpressionContext

	// SetMessage_type_name sets the message_type_name rule contexts.
	SetMessage_type_name(IExpressionContext)

	// IsSend_conversationContext differentiates from other interfaces.
	IsSend_conversationContext()
}

ISend_conversationContext is an interface to support dynamic dispatch.

type IService_broker_optionContext

type IService_broker_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsService_broker_optionContext differentiates from other interfaces.
	IsService_broker_optionContext()
}

IService_broker_optionContext is an interface to support dynamic dispatch.

type IService_nameContext

type IService_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsService_nameContext differentiates from other interfaces.
	IsService_nameContext()
}

IService_nameContext is an interface to support dynamic dispatch.

type ISet_specialContext

type ISet_specialContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSet_specialContext differentiates from other interfaces.
	IsSet_specialContext()
}

ISet_specialContext is an interface to support dynamic dispatch.

type ISet_statementContext

type ISet_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMember_name returns the member_name rule contexts.
	GetMember_name() IIdContext

	// SetMember_name sets the member_name rule contexts.
	SetMember_name(IIdContext)

	// IsSet_statementContext differentiates from other interfaces.
	IsSet_statementContext()
}

ISet_statementContext is an interface to support dynamic dispatch.

type ISetuser_statementContext

type ISetuser_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetUser returns the user token.
	GetUser() antlr.Token

	// SetUser sets the user token.
	SetUser(antlr.Token)

	// IsSetuser_statementContext differentiates from other interfaces.
	IsSetuser_statementContext()
}

ISetuser_statementContext is an interface to support dynamic dispatch.

type ISignContext

type ISignContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSignContext differentiates from other interfaces.
	IsSignContext()
}

ISignContext is an interface to support dynamic dispatch.

type ISimple_idContext

type ISimple_idContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSimple_idContext differentiates from other interfaces.
	IsSimple_idContext()
}

ISimple_idContext is an interface to support dynamic dispatch.

type ISimple_nameContext

type ISimple_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetName returns the name rule contexts.
	GetName() IIdContext

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetName sets the name rule contexts.
	SetName(IIdContext)

	// IsSimple_nameContext differentiates from other interfaces.
	IsSimple_nameContext()
}

ISimple_nameContext is an interface to support dynamic dispatch.

type ISnapshot_optionContext

type ISnapshot_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT returns the MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT token.
	GetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT() antlr.Token

	// SetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT sets the MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT token.
	SetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT(antlr.Token)

	// IsSnapshot_optionContext differentiates from other interfaces.
	IsSnapshot_optionContext()
}

ISnapshot_optionContext is an interface to support dynamic dispatch.

type ISql_clauseContext

type ISql_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSql_clauseContext differentiates from other interfaces.
	IsSql_clauseContext()
}

ISql_clauseContext is an interface to support dynamic dispatch.

type ISql_clausesContext

type ISql_clausesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSql_clausesContext differentiates from other interfaces.
	IsSql_clausesContext()
}

ISql_clausesContext is an interface to support dynamic dispatch.

type ISql_optionContext

type ISql_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSql_optionContext differentiates from other interfaces.
	IsSql_optionContext()
}

ISql_optionContext is an interface to support dynamic dispatch.

type ISql_unionContext

type ISql_unionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSql_unionContext differentiates from other interfaces.
	IsSql_unionContext()
}

ISql_unionContext is an interface to support dynamic dispatch.

type ISubqueryContext

type ISubqueryContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSubqueryContext differentiates from other interfaces.
	IsSubqueryContext()
}

ISubqueryContext is an interface to support dynamic dispatch.

type ISwitch_search_condition_sectionContext

type ISwitch_search_condition_sectionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSwitch_search_condition_sectionContext differentiates from other interfaces.
	IsSwitch_search_condition_sectionContext()
}

ISwitch_search_condition_sectionContext is an interface to support dynamic dispatch.

type ISwitch_sectionContext

type ISwitch_sectionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSwitch_sectionContext differentiates from other interfaces.
	IsSwitch_sectionContext()
}

ISwitch_sectionContext is an interface to support dynamic dispatch.

type ITable_aliasContext

type ITable_aliasContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_aliasContext differentiates from other interfaces.
	IsTable_aliasContext()
}

ITable_aliasContext is an interface to support dynamic dispatch.

type ITable_constraintContext

type ITable_constraintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetConstraint returns the constraint rule contexts.
	GetConstraint() IIdContext

	// GetFk returns the fk rule contexts.
	GetFk() IColumn_name_listContext

	// GetPk returns the pk rule contexts.
	GetPk() IColumn_name_listContext

	// SetConstraint sets the constraint rule contexts.
	SetConstraint(IIdContext)

	// SetFk sets the fk rule contexts.
	SetFk(IColumn_name_listContext)

	// SetPk sets the pk rule contexts.
	SetPk(IColumn_name_listContext)

	// IsTable_constraintContext differentiates from other interfaces.
	IsTable_constraintContext()
}

ITable_constraintContext is an interface to support dynamic dispatch.

type ITable_hintContext

type ITable_hintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_hintContext differentiates from other interfaces.
	IsTable_hintContext()
}

ITable_hintContext is an interface to support dynamic dispatch.

type ITable_nameContext

type ITable_nameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDatabase returns the database rule contexts.
	GetDatabase() IIdContext

	// GetSchema returns the schema rule contexts.
	GetSchema() IIdContext

	// GetTable returns the table rule contexts.
	GetTable() IIdContext

	// SetDatabase sets the database rule contexts.
	SetDatabase(IIdContext)

	// SetSchema sets the schema rule contexts.
	SetSchema(IIdContext)

	// SetTable sets the table rule contexts.
	SetTable(IIdContext)

	// IsTable_nameContext differentiates from other interfaces.
	IsTable_nameContext()
}

ITable_nameContext is an interface to support dynamic dispatch.

type ITable_name_with_hintContext

type ITable_name_with_hintContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_name_with_hintContext differentiates from other interfaces.
	IsTable_name_with_hintContext()
}

ITable_name_with_hintContext is an interface to support dynamic dispatch.

type ITable_optionsContext

type ITable_optionsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_optionsContext differentiates from other interfaces.
	IsTable_optionsContext()
}

ITable_optionsContext is an interface to support dynamic dispatch.

type ITable_sourceContext

type ITable_sourceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_sourceContext differentiates from other interfaces.
	IsTable_sourceContext()
}

ITable_sourceContext is an interface to support dynamic dispatch.

type ITable_source_itemContext

type ITable_source_itemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_source_itemContext differentiates from other interfaces.
	IsTable_source_itemContext()
}

ITable_source_itemContext is an interface to support dynamic dispatch.

type ITable_source_item_joinedContext

type ITable_source_item_joinedContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_source_item_joinedContext differentiates from other interfaces.
	IsTable_source_item_joinedContext()
}

ITable_source_item_joinedContext is an interface to support dynamic dispatch.

type ITable_sourcesContext

type ITable_sourcesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_sourcesContext differentiates from other interfaces.
	IsTable_sourcesContext()
}

ITable_sourcesContext is an interface to support dynamic dispatch.

type ITable_type_definitionContext

type ITable_type_definitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_type_definitionContext differentiates from other interfaces.
	IsTable_type_definitionContext()
}

ITable_type_definitionContext is an interface to support dynamic dispatch.

type ITable_value_constructorContext

type ITable_value_constructorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTable_value_constructorContext differentiates from other interfaces.
	IsTable_value_constructorContext()
}

ITable_value_constructorContext is an interface to support dynamic dispatch.

type ITarget_recovery_time_optionContext

type ITarget_recovery_time_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTarget_recovery_time_optionContext differentiates from other interfaces.
	IsTarget_recovery_time_optionContext()
}

ITarget_recovery_time_optionContext is an interface to support dynamic dispatch.

type ITerminationContext

type ITerminationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetSeconds returns the seconds token.
	GetSeconds() antlr.Token

	// SetSeconds sets the seconds token.
	SetSeconds(antlr.Token)

	// IsTerminationContext differentiates from other interfaces.
	IsTerminationContext()
}

ITerminationContext is an interface to support dynamic dispatch.

type IThrow_error_numberContext

type IThrow_error_numberContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsThrow_error_numberContext differentiates from other interfaces.
	IsThrow_error_numberContext()
}

IThrow_error_numberContext is an interface to support dynamic dispatch.

type IThrow_messageContext

type IThrow_messageContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsThrow_messageContext differentiates from other interfaces.
	IsThrow_messageContext()
}

IThrow_messageContext is an interface to support dynamic dispatch.

type IThrow_stateContext

type IThrow_stateContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsThrow_stateContext differentiates from other interfaces.
	IsThrow_stateContext()
}

IThrow_stateContext is an interface to support dynamic dispatch.

type IThrow_statementContext

type IThrow_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsThrow_statementContext differentiates from other interfaces.
	IsThrow_statementContext()
}

IThrow_statementContext is an interface to support dynamic dispatch.

type ITimeContext

type ITimeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTimeContext differentiates from other interfaces.
	IsTimeContext()
}

ITimeContext is an interface to support dynamic dispatch.

type ITop_clauseContext

type ITop_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTop_clauseContext differentiates from other interfaces.
	IsTop_clauseContext()
}

ITop_clauseContext is an interface to support dynamic dispatch.

type ITop_countContext

type ITop_countContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTop_countContext differentiates from other interfaces.
	IsTop_countContext()
}

ITop_countContext is an interface to support dynamic dispatch.

type ITop_percentContext

type ITop_percentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTop_percentContext differentiates from other interfaces.
	IsTop_percentContext()
}

ITop_percentContext is an interface to support dynamic dispatch.

type ITransaction_statementContext

type ITransaction_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTransaction_statementContext differentiates from other interfaces.
	IsTransaction_statementContext()
}

ITransaction_statementContext is an interface to support dynamic dispatch.

type ITruncate_tableContext

type ITruncate_tableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTruncate_tableContext differentiates from other interfaces.
	IsTruncate_tableContext()
}

ITruncate_tableContext is an interface to support dynamic dispatch.

type ITry_catch_statementContext

type ITry_catch_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetTry_clauses returns the try_clauses rule contexts.
	GetTry_clauses() ISql_clausesContext

	// GetCatch_clauses returns the catch_clauses rule contexts.
	GetCatch_clauses() ISql_clausesContext

	// SetTry_clauses sets the try_clauses rule contexts.
	SetTry_clauses(ISql_clausesContext)

	// SetCatch_clauses sets the catch_clauses rule contexts.
	SetCatch_clauses(ISql_clausesContext)

	// IsTry_catch_statementContext differentiates from other interfaces.
	IsTry_catch_statementContext()
}

ITry_catch_statementContext is an interface to support dynamic dispatch.

type ITsql_fileContext

type ITsql_fileContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsTsql_fileContext differentiates from other interfaces.
	IsTsql_fileContext()
}

ITsql_fileContext is an interface to support dynamic dispatch.

type IUdt_elemContext

type IUdt_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetUdt_column_name returns the udt_column_name rule contexts.
	GetUdt_column_name() IIdContext

	// GetNon_static_attr returns the non_static_attr rule contexts.
	GetNon_static_attr() IIdContext

	// GetStatic_attr returns the static_attr rule contexts.
	GetStatic_attr() IIdContext

	// SetUdt_column_name sets the udt_column_name rule contexts.
	SetUdt_column_name(IIdContext)

	// SetNon_static_attr sets the non_static_attr rule contexts.
	SetNon_static_attr(IIdContext)

	// SetStatic_attr sets the static_attr rule contexts.
	SetStatic_attr(IIdContext)

	// IsUdt_elemContext differentiates from other interfaces.
	IsUdt_elemContext()
}

IUdt_elemContext is an interface to support dynamic dispatch.

type IUdt_method_argumentsContext

type IUdt_method_argumentsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUdt_method_argumentsContext differentiates from other interfaces.
	IsUdt_method_argumentsContext()
}

IUdt_method_argumentsContext is an interface to support dynamic dispatch.

type IUnary_operator_expressionContext

type IUnary_operator_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOp returns the op token.
	GetOp() antlr.Token

	// SetOp sets the op token.
	SetOp(antlr.Token)

	// IsUnary_operator_expressionContext differentiates from other interfaces.
	IsUnary_operator_expressionContext()
}

IUnary_operator_expressionContext is an interface to support dynamic dispatch.

type IUnpivot_clauseContext

type IUnpivot_clauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnpivot_clauseContext differentiates from other interfaces.
	IsUnpivot_clauseContext()
}

IUnpivot_clauseContext is an interface to support dynamic dispatch.

type IUpdate_elemContext

type IUpdate_elemContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetUdt_column_name returns the udt_column_name rule contexts.
	GetUdt_column_name() IIdContext

	// GetMethod_name returns the method_name rule contexts.
	GetMethod_name() IIdContext

	// SetUdt_column_name sets the udt_column_name rule contexts.
	SetUdt_column_name(IIdContext)

	// SetMethod_name sets the method_name rule contexts.
	SetMethod_name(IIdContext)

	// IsUpdate_elemContext differentiates from other interfaces.
	IsUpdate_elemContext()
}

IUpdate_elemContext is an interface to support dynamic dispatch.

type IUpdate_statementContext

type IUpdate_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetCursor_var returns the cursor_var token.
	GetCursor_var() antlr.Token

	// SetCursor_var sets the cursor_var token.
	SetCursor_var(antlr.Token)

	// IsUpdate_statementContext differentiates from other interfaces.
	IsUpdate_statementContext()
}

IUpdate_statementContext is an interface to support dynamic dispatch.

type IUpdate_statisticsContext

type IUpdate_statisticsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUpdate_statisticsContext differentiates from other interfaces.
	IsUpdate_statisticsContext()
}

IUpdate_statisticsContext is an interface to support dynamic dispatch.

type IUse_statementContext

type IUse_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetDatabase returns the database rule contexts.
	GetDatabase() IIdContext

	// SetDatabase sets the database rule contexts.
	SetDatabase(IIdContext)

	// IsUse_statementContext differentiates from other interfaces.
	IsUse_statementContext()
}

IUse_statementContext is an interface to support dynamic dispatch.

type IValue_methodContext

type IValue_methodContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetXquery returns the xquery token.
	GetXquery() antlr.Token

	// GetSqltype returns the sqltype token.
	GetSqltype() antlr.Token

	// SetXquery sets the xquery token.
	SetXquery(antlr.Token)

	// SetSqltype sets the sqltype token.
	SetSqltype(antlr.Token)

	// IsValue_methodContext differentiates from other interfaces.
	IsValue_methodContext()
}

IValue_methodContext is an interface to support dynamic dispatch.

type IView_attributeContext

type IView_attributeContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsView_attributeContext differentiates from other interfaces.
	IsView_attributeContext()
}

IView_attributeContext is an interface to support dynamic dispatch.

type IWaitfor_conversationContext

type IWaitfor_conversationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetTimeout returns the timeout rule contexts.
	GetTimeout() ITimeContext

	// SetTimeout sets the timeout rule contexts.
	SetTimeout(ITimeContext)

	// IsWaitfor_conversationContext differentiates from other interfaces.
	IsWaitfor_conversationContext()
}

IWaitfor_conversationContext is an interface to support dynamic dispatch.

type IWaitfor_statementContext

type IWaitfor_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWaitfor_statementContext differentiates from other interfaces.
	IsWaitfor_statementContext()
}

IWaitfor_statementContext is an interface to support dynamic dispatch.

type IWhile_statementContext

type IWhile_statementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWhile_statementContext differentiates from other interfaces.
	IsWhile_statementContext()
}

IWhile_statementContext is an interface to support dynamic dispatch.

type IWindow_frame_boundContext

type IWindow_frame_boundContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWindow_frame_boundContext differentiates from other interfaces.
	IsWindow_frame_boundContext()
}

IWindow_frame_boundContext is an interface to support dynamic dispatch.

type IWindow_frame_extentContext

type IWindow_frame_extentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWindow_frame_extentContext differentiates from other interfaces.
	IsWindow_frame_extentContext()
}

IWindow_frame_extentContext is an interface to support dynamic dispatch.

type IWindow_frame_followingContext

type IWindow_frame_followingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWindow_frame_followingContext differentiates from other interfaces.
	IsWindow_frame_followingContext()
}

IWindow_frame_followingContext is an interface to support dynamic dispatch.

type IWindow_frame_precedingContext

type IWindow_frame_precedingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWindow_frame_precedingContext differentiates from other interfaces.
	IsWindow_frame_precedingContext()
}

IWindow_frame_precedingContext is an interface to support dynamic dispatch.

type IWith_expressionContext

type IWith_expressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWith_expressionContext differentiates from other interfaces.
	IsWith_expressionContext()
}

IWith_expressionContext is an interface to support dynamic dispatch.

type IWith_table_hintsContext

type IWith_table_hintsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWith_table_hintsContext differentiates from other interfaces.
	IsWith_table_hintsContext()
}

IWith_table_hintsContext is an interface to support dynamic dispatch.

type IWitness_optionContext

type IWitness_optionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWitness_optionContext differentiates from other interfaces.
	IsWitness_optionContext()
}

IWitness_optionContext is an interface to support dynamic dispatch.

type IWitness_partner_equalContext

type IWitness_partner_equalContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWitness_partner_equalContext differentiates from other interfaces.
	IsWitness_partner_equalContext()
}

IWitness_partner_equalContext is an interface to support dynamic dispatch.

type IWitness_serverContext

type IWitness_serverContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsWitness_serverContext differentiates from other interfaces.
	IsWitness_serverContext()
}

IWitness_serverContext is an interface to support dynamic dispatch.

type IXml_common_directivesContext

type IXml_common_directivesContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsXml_common_directivesContext differentiates from other interfaces.
	IsXml_common_directivesContext()
}

IXml_common_directivesContext is an interface to support dynamic dispatch.

type IXml_data_type_methodsContext

type IXml_data_type_methodsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsXml_data_type_methodsContext differentiates from other interfaces.
	IsXml_data_type_methodsContext()
}

IXml_data_type_methodsContext is an interface to support dynamic dispatch.

type IXml_schema_collectionContext

type IXml_schema_collectionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsXml_schema_collectionContext differentiates from other interfaces.
	IsXml_schema_collectionContext()
}

IXml_schema_collectionContext is an interface to support dynamic dispatch.

type IXml_type_definitionContext

type IXml_type_definitionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsXml_type_definitionContext differentiates from other interfaces.
	IsXml_type_definitionContext()
}

IXml_type_definitionContext is an interface to support dynamic dispatch.

type IdContext

type IdContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIdContext

func NewEmptyIdContext() *IdContext

func NewIdContext

func NewIdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdContext

func (*IdContext) DOUBLE_QUOTE_ID

func (s *IdContext) DOUBLE_QUOTE_ID() antlr.TerminalNode

func (*IdContext) EnterRule

func (s *IdContext) EnterRule(listener antlr.ParseTreeListener)

func (*IdContext) ExitRule

func (s *IdContext) ExitRule(listener antlr.ParseTreeListener)

func (*IdContext) GetParser

func (s *IdContext) GetParser() antlr.Parser

func (*IdContext) GetRuleContext

func (s *IdContext) GetRuleContext() antlr.RuleContext

func (*IdContext) IsIdContext

func (*IdContext) IsIdContext()

func (*IdContext) SQUARE_BRACKET_ID

func (s *IdContext) SQUARE_BRACKET_ID() antlr.TerminalNode

func (*IdContext) Simple_id

func (s *IdContext) Simple_id() ISimple_idContext

func (*IdContext) ToStringTree

func (s *IdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type If_statementContext

type If_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIf_statementContext

func NewEmptyIf_statementContext() *If_statementContext

func NewIf_statementContext

func NewIf_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_statementContext

func (*If_statementContext) AllSql_clause

func (s *If_statementContext) AllSql_clause() []ISql_clauseContext

func (*If_statementContext) ELSE

func (*If_statementContext) EnterRule

func (s *If_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*If_statementContext) ExitRule

func (s *If_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*If_statementContext) GetParser

func (s *If_statementContext) GetParser() antlr.Parser

func (*If_statementContext) GetRuleContext

func (s *If_statementContext) GetRuleContext() antlr.RuleContext

func (*If_statementContext) IF

func (*If_statementContext) IsIf_statementContext

func (*If_statementContext) IsIf_statementContext()

func (*If_statementContext) SEMI

func (*If_statementContext) Search_condition

func (s *If_statementContext) Search_condition() ISearch_conditionContext

func (*If_statementContext) Sql_clause

func (s *If_statementContext) Sql_clause(i int) ISql_clauseContext

func (*If_statementContext) ToStringTree

func (s *If_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Index_optionContext

type Index_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndex_optionContext

func NewEmptyIndex_optionContext() *Index_optionContext

func NewIndex_optionContext

func NewIndex_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_optionContext

func (*Index_optionContext) AllSimple_id

func (s *Index_optionContext) AllSimple_id() []ISimple_idContext

func (*Index_optionContext) DECIMAL

func (s *Index_optionContext) DECIMAL() antlr.TerminalNode

func (*Index_optionContext) EQUAL

func (*Index_optionContext) EnterRule

func (s *Index_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Index_optionContext) ExitRule

func (s *Index_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Index_optionContext) GetParser

func (s *Index_optionContext) GetParser() antlr.Parser

func (*Index_optionContext) GetRuleContext

func (s *Index_optionContext) GetRuleContext() antlr.RuleContext

func (*Index_optionContext) IsIndex_optionContext

func (*Index_optionContext) IsIndex_optionContext()

func (*Index_optionContext) On_off

func (s *Index_optionContext) On_off() IOn_offContext

func (*Index_optionContext) Simple_id

func (s *Index_optionContext) Simple_id(i int) ISimple_idContext

func (*Index_optionContext) ToStringTree

func (s *Index_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Index_optionsContext

type Index_optionsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndex_optionsContext

func NewEmptyIndex_optionsContext() *Index_optionsContext

func NewIndex_optionsContext

func NewIndex_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_optionsContext

func (*Index_optionsContext) AllCOMMA

func (s *Index_optionsContext) AllCOMMA() []antlr.TerminalNode

func (*Index_optionsContext) AllIndex_option

func (s *Index_optionsContext) AllIndex_option() []IIndex_optionContext

func (*Index_optionsContext) COMMA

func (*Index_optionsContext) EnterRule

func (s *Index_optionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Index_optionsContext) ExitRule

func (s *Index_optionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Index_optionsContext) GetParser

func (s *Index_optionsContext) GetParser() antlr.Parser

func (*Index_optionsContext) GetRuleContext

func (s *Index_optionsContext) GetRuleContext() antlr.RuleContext

func (*Index_optionsContext) Index_option

func (s *Index_optionsContext) Index_option(i int) IIndex_optionContext

func (*Index_optionsContext) IsIndex_optionsContext

func (*Index_optionsContext) IsIndex_optionsContext()

func (*Index_optionsContext) LR_BRACKET

func (s *Index_optionsContext) LR_BRACKET() antlr.TerminalNode

func (*Index_optionsContext) RR_BRACKET

func (s *Index_optionsContext) RR_BRACKET() antlr.TerminalNode

func (*Index_optionsContext) ToStringTree

func (s *Index_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Index_optionsContext) WITH

type Index_valueContext

type Index_valueContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIndex_valueContext

func NewEmptyIndex_valueContext() *Index_valueContext

func NewIndex_valueContext

func NewIndex_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_valueContext

func (*Index_valueContext) DECIMAL

func (s *Index_valueContext) DECIMAL() antlr.TerminalNode

func (*Index_valueContext) EnterRule

func (s *Index_valueContext) EnterRule(listener antlr.ParseTreeListener)

func (*Index_valueContext) ExitRule

func (s *Index_valueContext) ExitRule(listener antlr.ParseTreeListener)

func (*Index_valueContext) GetParser

func (s *Index_valueContext) GetParser() antlr.Parser

func (*Index_valueContext) GetRuleContext

func (s *Index_valueContext) GetRuleContext() antlr.RuleContext

func (*Index_valueContext) Id

func (*Index_valueContext) IsIndex_valueContext

func (*Index_valueContext) IsIndex_valueContext()

func (*Index_valueContext) ToStringTree

func (s *Index_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Insert_statementContext

type Insert_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyInsert_statementContext

func NewEmptyInsert_statementContext() *Insert_statementContext

func NewInsert_statementContext

func NewInsert_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_statementContext

func (*Insert_statementContext) AllLR_BRACKET

func (s *Insert_statementContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Insert_statementContext) AllRR_BRACKET

func (s *Insert_statementContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Insert_statementContext) Column_name_list

func (s *Insert_statementContext) Column_name_list() IColumn_name_listContext

func (*Insert_statementContext) Ddl_object

func (*Insert_statementContext) EnterRule

func (s *Insert_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Insert_statementContext) ExitRule

func (s *Insert_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Insert_statementContext) Expression

func (*Insert_statementContext) For_clause

func (*Insert_statementContext) GetParser

func (s *Insert_statementContext) GetParser() antlr.Parser

func (*Insert_statementContext) GetRuleContext

func (s *Insert_statementContext) GetRuleContext() antlr.RuleContext

func (*Insert_statementContext) INSERT

func (*Insert_statementContext) INTO

func (*Insert_statementContext) Insert_statement_value

func (s *Insert_statementContext) Insert_statement_value() IInsert_statement_valueContext

func (*Insert_statementContext) Insert_with_table_hints

func (s *Insert_statementContext) Insert_with_table_hints() IInsert_with_table_hintsContext

func (*Insert_statementContext) IsInsert_statementContext

func (*Insert_statementContext) IsInsert_statementContext()

func (*Insert_statementContext) LR_BRACKET

func (s *Insert_statementContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Insert_statementContext) Option_clause

func (*Insert_statementContext) Output_clause

func (*Insert_statementContext) PERCENT

func (*Insert_statementContext) RR_BRACKET

func (s *Insert_statementContext) RR_BRACKET(i int) antlr.TerminalNode

func (*Insert_statementContext) Rowset_function_limited

func (s *Insert_statementContext) Rowset_function_limited() IRowset_function_limitedContext

func (*Insert_statementContext) SEMI

func (*Insert_statementContext) TOP

func (*Insert_statementContext) ToStringTree

func (s *Insert_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Insert_statementContext) With_expression

func (s *Insert_statementContext) With_expression() IWith_expressionContext

type Insert_statement_valueContext

type Insert_statement_valueContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyInsert_statement_valueContext

func NewEmptyInsert_statement_valueContext() *Insert_statement_valueContext

func NewInsert_statement_valueContext

func NewInsert_statement_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_statement_valueContext

func (*Insert_statement_valueContext) DEFAULT

func (*Insert_statement_valueContext) Derived_table

func (*Insert_statement_valueContext) EnterRule

func (s *Insert_statement_valueContext) EnterRule(listener antlr.ParseTreeListener)

func (*Insert_statement_valueContext) Execute_statement

func (*Insert_statement_valueContext) ExitRule

func (*Insert_statement_valueContext) GetParser

func (*Insert_statement_valueContext) GetRuleContext

func (s *Insert_statement_valueContext) GetRuleContext() antlr.RuleContext

func (*Insert_statement_valueContext) IsInsert_statement_valueContext

func (*Insert_statement_valueContext) IsInsert_statement_valueContext()

func (*Insert_statement_valueContext) Table_value_constructor

func (*Insert_statement_valueContext) ToStringTree

func (s *Insert_statement_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Insert_statement_valueContext) VALUES

type Insert_with_table_hintsContext

type Insert_with_table_hintsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyInsert_with_table_hintsContext

func NewEmptyInsert_with_table_hintsContext() *Insert_with_table_hintsContext

func NewInsert_with_table_hintsContext

func NewInsert_with_table_hintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_with_table_hintsContext

func (*Insert_with_table_hintsContext) AllCOMMA

func (*Insert_with_table_hintsContext) AllTable_hint

func (*Insert_with_table_hintsContext) COMMA

func (*Insert_with_table_hintsContext) EnterRule

func (*Insert_with_table_hintsContext) ExitRule

func (*Insert_with_table_hintsContext) GetParser

func (*Insert_with_table_hintsContext) GetRuleContext

func (s *Insert_with_table_hintsContext) GetRuleContext() antlr.RuleContext

func (*Insert_with_table_hintsContext) IsInsert_with_table_hintsContext

func (*Insert_with_table_hintsContext) IsInsert_with_table_hintsContext()

func (*Insert_with_table_hintsContext) LR_BRACKET

func (*Insert_with_table_hintsContext) RR_BRACKET

func (*Insert_with_table_hintsContext) Table_hint

func (*Insert_with_table_hintsContext) ToStringTree

func (s *Insert_with_table_hintsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Insert_with_table_hintsContext) WITH

type Join_partContext

type Join_partContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyJoin_partContext

func NewEmptyJoin_partContext() *Join_partContext

func NewJoin_partContext

func NewJoin_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_partContext

func (*Join_partContext) APPLY

func (s *Join_partContext) APPLY() antlr.TerminalNode

func (*Join_partContext) As_table_alias

func (s *Join_partContext) As_table_alias() IAs_table_aliasContext

func (*Join_partContext) CROSS

func (s *Join_partContext) CROSS() antlr.TerminalNode

func (*Join_partContext) EnterRule

func (s *Join_partContext) EnterRule(listener antlr.ParseTreeListener)

func (*Join_partContext) ExitRule

func (s *Join_partContext) ExitRule(listener antlr.ParseTreeListener)

func (*Join_partContext) FULL

func (*Join_partContext) GetJoin_hint

func (s *Join_partContext) GetJoin_hint() antlr.Token

func (*Join_partContext) GetJoin_type

func (s *Join_partContext) GetJoin_type() antlr.Token

func (*Join_partContext) GetParser

func (s *Join_partContext) GetParser() antlr.Parser

func (*Join_partContext) GetRuleContext

func (s *Join_partContext) GetRuleContext() antlr.RuleContext

func (*Join_partContext) HASH

func (*Join_partContext) INNER

func (s *Join_partContext) INNER() antlr.TerminalNode

func (*Join_partContext) IsJoin_partContext

func (*Join_partContext) IsJoin_partContext()

func (*Join_partContext) JOIN

func (*Join_partContext) LEFT

func (*Join_partContext) LOOP

func (*Join_partContext) MERGE

func (s *Join_partContext) MERGE() antlr.TerminalNode

func (*Join_partContext) ON

func (*Join_partContext) OUTER

func (s *Join_partContext) OUTER() antlr.TerminalNode

func (*Join_partContext) PIVOT

func (s *Join_partContext) PIVOT() antlr.TerminalNode

func (*Join_partContext) Pivot_clause

func (s *Join_partContext) Pivot_clause() IPivot_clauseContext

func (*Join_partContext) REMOTE

func (s *Join_partContext) REMOTE() antlr.TerminalNode

func (*Join_partContext) RIGHT

func (s *Join_partContext) RIGHT() antlr.TerminalNode

func (*Join_partContext) Search_condition

func (s *Join_partContext) Search_condition() ISearch_conditionContext

func (*Join_partContext) SetJoin_hint

func (s *Join_partContext) SetJoin_hint(v antlr.Token)

func (*Join_partContext) SetJoin_type

func (s *Join_partContext) SetJoin_type(v antlr.Token)

func (*Join_partContext) Table_source

func (s *Join_partContext) Table_source() ITable_sourceContext

func (*Join_partContext) ToStringTree

func (s *Join_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Join_partContext) UNPIVOT

func (s *Join_partContext) UNPIVOT() antlr.TerminalNode

func (*Join_partContext) Unpivot_clause

func (s *Join_partContext) Unpivot_clause() IUnpivot_clauseContext

type Key_optionsContext

type Key_optionsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyKey_optionsContext

func NewEmptyKey_optionsContext() *Key_optionsContext

func NewKey_optionsContext

func NewKey_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_optionsContext

func (*Key_optionsContext) ALGORITHM

func (s *Key_optionsContext) ALGORITHM() antlr.TerminalNode

func (*Key_optionsContext) Algorithm

func (s *Key_optionsContext) Algorithm() IAlgorithmContext

func (*Key_optionsContext) CREATE_NEW

func (s *Key_optionsContext) CREATE_NEW() antlr.TerminalNode

func (*Key_optionsContext) CREATION_DISPOSITION

func (s *Key_optionsContext) CREATION_DISPOSITION() antlr.TerminalNode

func (*Key_optionsContext) EQUAL

func (*Key_optionsContext) EnterRule

func (s *Key_optionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Key_optionsContext) ExitRule

func (s *Key_optionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Key_optionsContext) GetIdentity_phrase

func (s *Key_optionsContext) GetIdentity_phrase() antlr.Token

func (*Key_optionsContext) GetKey_name_in_provider

func (s *Key_optionsContext) GetKey_name_in_provider() antlr.Token

func (*Key_optionsContext) GetParser

func (s *Key_optionsContext) GetParser() antlr.Parser

func (*Key_optionsContext) GetPass_phrase

func (s *Key_optionsContext) GetPass_phrase() antlr.Token

func (*Key_optionsContext) GetRuleContext

func (s *Key_optionsContext) GetRuleContext() antlr.RuleContext

func (*Key_optionsContext) IDENTITY_VALUE

func (s *Key_optionsContext) IDENTITY_VALUE() antlr.TerminalNode

func (*Key_optionsContext) IsKey_optionsContext

func (*Key_optionsContext) IsKey_optionsContext()

func (*Key_optionsContext) KEY_SOURCE

func (s *Key_optionsContext) KEY_SOURCE() antlr.TerminalNode

func (*Key_optionsContext) OPEN_EXISTING

func (s *Key_optionsContext) OPEN_EXISTING() antlr.TerminalNode

func (*Key_optionsContext) PROVIDER_KEY_NAME

func (s *Key_optionsContext) PROVIDER_KEY_NAME() antlr.TerminalNode

func (*Key_optionsContext) STRING

func (*Key_optionsContext) SetIdentity_phrase

func (s *Key_optionsContext) SetIdentity_phrase(v antlr.Token)

func (*Key_optionsContext) SetKey_name_in_provider

func (s *Key_optionsContext) SetKey_name_in_provider(v antlr.Token)

func (*Key_optionsContext) SetPass_phrase

func (s *Key_optionsContext) SetPass_phrase(v antlr.Token)

func (*Key_optionsContext) ToStringTree

func (s *Key_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Local_driveContext

type Local_driveContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLocal_driveContext

func NewEmptyLocal_driveContext() *Local_driveContext

func NewLocal_driveContext

func NewLocal_driveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_driveContext

func (*Local_driveContext) DISK_DRIVE

func (s *Local_driveContext) DISK_DRIVE() antlr.TerminalNode

func (*Local_driveContext) EnterRule

func (s *Local_driveContext) EnterRule(listener antlr.ParseTreeListener)

func (*Local_driveContext) ExitRule

func (s *Local_driveContext) ExitRule(listener antlr.ParseTreeListener)

func (*Local_driveContext) GetParser

func (s *Local_driveContext) GetParser() antlr.Parser

func (*Local_driveContext) GetRuleContext

func (s *Local_driveContext) GetRuleContext() antlr.RuleContext

func (*Local_driveContext) IsLocal_driveContext

func (*Local_driveContext) IsLocal_driveContext()

func (*Local_driveContext) ToStringTree

func (s *Local_driveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Local_fileContext

type Local_fileContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLocal_fileContext

func NewEmptyLocal_fileContext() *Local_fileContext

func NewLocal_fileContext

func NewLocal_fileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_fileContext

func (*Local_fileContext) EnterRule

func (s *Local_fileContext) EnterRule(listener antlr.ParseTreeListener)

func (*Local_fileContext) ExitRule

func (s *Local_fileContext) ExitRule(listener antlr.ParseTreeListener)

func (*Local_fileContext) File_path

func (s *Local_fileContext) File_path() IFile_pathContext

func (*Local_fileContext) GetParser

func (s *Local_fileContext) GetParser() antlr.Parser

func (*Local_fileContext) GetRuleContext

func (s *Local_fileContext) GetRuleContext() antlr.RuleContext

func (*Local_fileContext) IsLocal_fileContext

func (*Local_fileContext) IsLocal_fileContext()

func (*Local_fileContext) Local_drive

func (s *Local_fileContext) Local_drive() ILocal_driveContext

func (*Local_fileContext) ToStringTree

func (s *Local_fileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Lock_tableContext

type Lock_tableContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLock_tableContext

func NewEmptyLock_tableContext() *Lock_tableContext

func NewLock_tableContext

func NewLock_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_tableContext

func (*Lock_tableContext) DECIMAL

func (s *Lock_tableContext) DECIMAL() antlr.TerminalNode

func (*Lock_tableContext) EXCLUSIVE

func (s *Lock_tableContext) EXCLUSIVE() antlr.TerminalNode

func (*Lock_tableContext) EnterRule

func (s *Lock_tableContext) EnterRule(listener antlr.ParseTreeListener)

func (*Lock_tableContext) ExitRule

func (s *Lock_tableContext) ExitRule(listener antlr.ParseTreeListener)

func (*Lock_tableContext) GetParser

func (s *Lock_tableContext) GetParser() antlr.Parser

func (*Lock_tableContext) GetRuleContext

func (s *Lock_tableContext) GetRuleContext() antlr.RuleContext

func (*Lock_tableContext) GetSeconds

func (s *Lock_tableContext) GetSeconds() antlr.Token

func (*Lock_tableContext) IN

func (*Lock_tableContext) IsLock_tableContext

func (*Lock_tableContext) IsLock_tableContext()

func (*Lock_tableContext) LOCK

func (*Lock_tableContext) MODE

func (*Lock_tableContext) NOWAIT

func (s *Lock_tableContext) NOWAIT() antlr.TerminalNode

func (*Lock_tableContext) SEMI

func (*Lock_tableContext) SHARE

func (*Lock_tableContext) SetSeconds

func (s *Lock_tableContext) SetSeconds(v antlr.Token)

func (*Lock_tableContext) TABLE

func (*Lock_tableContext) Table_name

func (s *Lock_tableContext) Table_name() ITable_nameContext

func (*Lock_tableContext) ToStringTree

func (s *Lock_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Lock_tableContext) WAIT

type MIN_ACTIVE_ROWVERSIONContext

type MIN_ACTIVE_ROWVERSIONContext struct {
	*Function_callContext
}

func NewMIN_ACTIVE_ROWVERSIONContext

func NewMIN_ACTIVE_ROWVERSIONContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *MIN_ACTIVE_ROWVERSIONContext

func (*MIN_ACTIVE_ROWVERSIONContext) EnterRule

func (s *MIN_ACTIVE_ROWVERSIONContext) EnterRule(listener antlr.ParseTreeListener)

func (*MIN_ACTIVE_ROWVERSIONContext) ExitRule

func (*MIN_ACTIVE_ROWVERSIONContext) GetRuleContext

func (s *MIN_ACTIVE_ROWVERSIONContext) GetRuleContext() antlr.RuleContext

func (*MIN_ACTIVE_ROWVERSIONContext) MIN_ACTIVE_ROWVERSION

func (s *MIN_ACTIVE_ROWVERSIONContext) MIN_ACTIVE_ROWVERSION() antlr.TerminalNode

type Materialized_column_definitionContext

type Materialized_column_definitionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMaterialized_column_definitionContext

func NewEmptyMaterialized_column_definitionContext() *Materialized_column_definitionContext

func NewMaterialized_column_definitionContext

func NewMaterialized_column_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Materialized_column_definitionContext

func (*Materialized_column_definitionContext) AS

func (*Materialized_column_definitionContext) COMPUTE

func (*Materialized_column_definitionContext) EnterRule

func (*Materialized_column_definitionContext) ExitRule

func (*Materialized_column_definitionContext) Expression

func (*Materialized_column_definitionContext) GetParser

func (*Materialized_column_definitionContext) GetRuleContext

func (*Materialized_column_definitionContext) Id

func (*Materialized_column_definitionContext) IsMaterialized_column_definitionContext

func (*Materialized_column_definitionContext) IsMaterialized_column_definitionContext()

func (*Materialized_column_definitionContext) MATERIALIZED

func (*Materialized_column_definitionContext) NOT

func (*Materialized_column_definitionContext) ToStringTree

func (s *Materialized_column_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Merge_matchedContext

type Merge_matchedContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMerge_matchedContext

func NewEmptyMerge_matchedContext() *Merge_matchedContext

func NewMerge_matchedContext

func NewMerge_matchedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_matchedContext

func (*Merge_matchedContext) AllCOMMA

func (s *Merge_matchedContext) AllCOMMA() []antlr.TerminalNode

func (*Merge_matchedContext) AllUpdate_elem

func (s *Merge_matchedContext) AllUpdate_elem() []IUpdate_elemContext

func (*Merge_matchedContext) COMMA

func (*Merge_matchedContext) DELETE

func (*Merge_matchedContext) EnterRule

func (s *Merge_matchedContext) EnterRule(listener antlr.ParseTreeListener)

func (*Merge_matchedContext) ExitRule

func (s *Merge_matchedContext) ExitRule(listener antlr.ParseTreeListener)

func (*Merge_matchedContext) GetParser

func (s *Merge_matchedContext) GetParser() antlr.Parser

func (*Merge_matchedContext) GetRuleContext

func (s *Merge_matchedContext) GetRuleContext() antlr.RuleContext

func (*Merge_matchedContext) IsMerge_matchedContext

func (*Merge_matchedContext) IsMerge_matchedContext()

func (*Merge_matchedContext) SET

func (*Merge_matchedContext) ToStringTree

func (s *Merge_matchedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Merge_matchedContext) UPDATE

func (*Merge_matchedContext) Update_elem

func (s *Merge_matchedContext) Update_elem(i int) IUpdate_elemContext

type Merge_not_matchedContext

type Merge_not_matchedContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMerge_not_matchedContext

func NewEmptyMerge_not_matchedContext() *Merge_not_matchedContext

func NewMerge_not_matchedContext

func NewMerge_not_matchedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_not_matchedContext

func (*Merge_not_matchedContext) Column_name_list

func (s *Merge_not_matchedContext) Column_name_list() IColumn_name_listContext

func (*Merge_not_matchedContext) DEFAULT

func (*Merge_not_matchedContext) EnterRule

func (s *Merge_not_matchedContext) EnterRule(listener antlr.ParseTreeListener)

func (*Merge_not_matchedContext) ExitRule

func (s *Merge_not_matchedContext) ExitRule(listener antlr.ParseTreeListener)

func (*Merge_not_matchedContext) GetParser

func (s *Merge_not_matchedContext) GetParser() antlr.Parser

func (*Merge_not_matchedContext) GetRuleContext

func (s *Merge_not_matchedContext) GetRuleContext() antlr.RuleContext

func (*Merge_not_matchedContext) INSERT

func (*Merge_not_matchedContext) IsMerge_not_matchedContext

func (*Merge_not_matchedContext) IsMerge_not_matchedContext()

func (*Merge_not_matchedContext) LR_BRACKET

func (*Merge_not_matchedContext) RR_BRACKET

func (*Merge_not_matchedContext) Table_value_constructor

func (s *Merge_not_matchedContext) Table_value_constructor() ITable_value_constructorContext

func (*Merge_not_matchedContext) ToStringTree

func (s *Merge_not_matchedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Merge_not_matchedContext) VALUES

type Merge_statementContext

type Merge_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMerge_statementContext

func NewEmptyMerge_statementContext() *Merge_statementContext

func NewMerge_statementContext

func NewMerge_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_statementContext

func (*Merge_statementContext) AND

func (*Merge_statementContext) AllAND

func (*Merge_statementContext) AllBY

func (*Merge_statementContext) AllMATCHED

func (s *Merge_statementContext) AllMATCHED() []antlr.TerminalNode

func (*Merge_statementContext) AllMerge_matched

func (s *Merge_statementContext) AllMerge_matched() []IMerge_matchedContext

func (*Merge_statementContext) AllNOT

func (*Merge_statementContext) AllSOURCE

func (s *Merge_statementContext) AllSOURCE() []antlr.TerminalNode

func (*Merge_statementContext) AllSearch_condition

func (s *Merge_statementContext) AllSearch_condition() []ISearch_conditionContext

func (*Merge_statementContext) AllTHEN

func (s *Merge_statementContext) AllTHEN() []antlr.TerminalNode

func (*Merge_statementContext) AllWHEN

func (s *Merge_statementContext) AllWHEN() []antlr.TerminalNode

func (*Merge_statementContext) As_table_alias

func (s *Merge_statementContext) As_table_alias() IAs_table_aliasContext

func (*Merge_statementContext) BY

func (*Merge_statementContext) Ddl_object

func (*Merge_statementContext) EnterRule

func (s *Merge_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Merge_statementContext) ExitRule

func (s *Merge_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Merge_statementContext) Expression

func (*Merge_statementContext) GetParser

func (s *Merge_statementContext) GetParser() antlr.Parser

func (*Merge_statementContext) GetRuleContext

func (s *Merge_statementContext) GetRuleContext() antlr.RuleContext

func (*Merge_statementContext) INTO

func (*Merge_statementContext) Insert_with_table_hints

func (s *Merge_statementContext) Insert_with_table_hints() IInsert_with_table_hintsContext

func (*Merge_statementContext) IsMerge_statementContext

func (*Merge_statementContext) IsMerge_statementContext()

func (*Merge_statementContext) LR_BRACKET

func (s *Merge_statementContext) LR_BRACKET() antlr.TerminalNode

func (*Merge_statementContext) MATCHED

func (*Merge_statementContext) MERGE

func (*Merge_statementContext) Merge_matched

func (s *Merge_statementContext) Merge_matched(i int) IMerge_matchedContext

func (*Merge_statementContext) Merge_not_matched

func (s *Merge_statementContext) Merge_not_matched() IMerge_not_matchedContext

func (*Merge_statementContext) NOT

func (*Merge_statementContext) ON

func (*Merge_statementContext) Option_clause

func (s *Merge_statementContext) Option_clause() IOption_clauseContext

func (*Merge_statementContext) Output_clause

func (s *Merge_statementContext) Output_clause() IOutput_clauseContext

func (*Merge_statementContext) PERCENT

func (*Merge_statementContext) RR_BRACKET

func (s *Merge_statementContext) RR_BRACKET() antlr.TerminalNode

func (*Merge_statementContext) SEMI

func (*Merge_statementContext) SOURCE

func (*Merge_statementContext) Search_condition

func (s *Merge_statementContext) Search_condition(i int) ISearch_conditionContext

func (*Merge_statementContext) TARGET

func (*Merge_statementContext) THEN

func (*Merge_statementContext) TOP

func (*Merge_statementContext) Table_sources

func (s *Merge_statementContext) Table_sources() ITable_sourcesContext

func (*Merge_statementContext) ToStringTree

func (s *Merge_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Merge_statementContext) USING

func (*Merge_statementContext) WHEN

func (*Merge_statementContext) With_expression

func (s *Merge_statementContext) With_expression() IWith_expressionContext

type Message_statementContext

type Message_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMessage_statementContext

func NewEmptyMessage_statementContext() *Message_statementContext

func NewMessage_statementContext

func NewMessage_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Message_statementContext

func (*Message_statementContext) AUTHORIZATION

func (s *Message_statementContext) AUTHORIZATION() antlr.TerminalNode

func (*Message_statementContext) AllId

func (s *Message_statementContext) AllId() []IIdContext

func (*Message_statementContext) COLLECTION

func (*Message_statementContext) CREATE

func (*Message_statementContext) EMPTY

func (*Message_statementContext) EQUAL

func (*Message_statementContext) EnterRule

func (s *Message_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Message_statementContext) ExitRule

func (s *Message_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Message_statementContext) GetMessage_type_name

func (s *Message_statementContext) GetMessage_type_name() IIdContext

func (*Message_statementContext) GetOwner_name

func (s *Message_statementContext) GetOwner_name() IIdContext

func (*Message_statementContext) GetParser

func (s *Message_statementContext) GetParser() antlr.Parser

func (*Message_statementContext) GetRuleContext

func (s *Message_statementContext) GetRuleContext() antlr.RuleContext

func (*Message_statementContext) GetSchema_collection_name

func (s *Message_statementContext) GetSchema_collection_name() IIdContext

func (*Message_statementContext) Id

func (*Message_statementContext) IsMessage_statementContext

func (*Message_statementContext) IsMessage_statementContext()

func (*Message_statementContext) MESSAGE

func (*Message_statementContext) NONE

func (*Message_statementContext) SCHEMA

func (*Message_statementContext) SetMessage_type_name

func (s *Message_statementContext) SetMessage_type_name(v IIdContext)

func (*Message_statementContext) SetOwner_name

func (s *Message_statementContext) SetOwner_name(v IIdContext)

func (*Message_statementContext) SetSchema_collection_name

func (s *Message_statementContext) SetSchema_collection_name(v IIdContext)

func (*Message_statementContext) TYPE

func (*Message_statementContext) ToStringTree

func (s *Message_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Message_statementContext) VALIDATION

func (*Message_statementContext) VALID_XML

func (*Message_statementContext) WELL_FORMED_XML

func (s *Message_statementContext) WELL_FORMED_XML() antlr.TerminalNode

func (*Message_statementContext) WITH

type Mirroring_host_port_seperatorContext

type Mirroring_host_port_seperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMirroring_host_port_seperatorContext

func NewEmptyMirroring_host_port_seperatorContext() *Mirroring_host_port_seperatorContext

func NewMirroring_host_port_seperatorContext

func NewMirroring_host_port_seperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mirroring_host_port_seperatorContext

func (*Mirroring_host_port_seperatorContext) COLON

func (*Mirroring_host_port_seperatorContext) EnterRule

func (*Mirroring_host_port_seperatorContext) ExitRule

func (*Mirroring_host_port_seperatorContext) GetParser

func (*Mirroring_host_port_seperatorContext) GetRuleContext

func (*Mirroring_host_port_seperatorContext) IsMirroring_host_port_seperatorContext

func (*Mirroring_host_port_seperatorContext) IsMirroring_host_port_seperatorContext()

func (*Mirroring_host_port_seperatorContext) ToStringTree

func (s *Mirroring_host_port_seperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Mirroring_partnerContext

type Mirroring_partnerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMirroring_partnerContext

func NewEmptyMirroring_partnerContext() *Mirroring_partnerContext

func NewMirroring_partnerContext

func NewMirroring_partnerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mirroring_partnerContext

func (*Mirroring_partnerContext) EnterRule

func (s *Mirroring_partnerContext) EnterRule(listener antlr.ParseTreeListener)

func (*Mirroring_partnerContext) ExitRule

func (s *Mirroring_partnerContext) ExitRule(listener antlr.ParseTreeListener)

func (*Mirroring_partnerContext) GetParser

func (s *Mirroring_partnerContext) GetParser() antlr.Parser

func (*Mirroring_partnerContext) GetRuleContext

func (s *Mirroring_partnerContext) GetRuleContext() antlr.RuleContext

func (*Mirroring_partnerContext) IsMirroring_partnerContext

func (*Mirroring_partnerContext) IsMirroring_partnerContext()

func (*Mirroring_partnerContext) PARTNER

func (*Mirroring_partnerContext) ToStringTree

func (s *Mirroring_partnerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Mirroring_set_optionContext

type Mirroring_set_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMirroring_set_optionContext

func NewEmptyMirroring_set_optionContext() *Mirroring_set_optionContext

func NewMirroring_set_optionContext

func NewMirroring_set_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mirroring_set_optionContext

func (*Mirroring_set_optionContext) EnterRule

func (s *Mirroring_set_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Mirroring_set_optionContext) ExitRule

func (s *Mirroring_set_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Mirroring_set_optionContext) GetParser

func (s *Mirroring_set_optionContext) GetParser() antlr.Parser

func (*Mirroring_set_optionContext) GetRuleContext

func (s *Mirroring_set_optionContext) GetRuleContext() antlr.RuleContext

func (*Mirroring_set_optionContext) IsMirroring_set_optionContext

func (*Mirroring_set_optionContext) IsMirroring_set_optionContext()

func (*Mirroring_set_optionContext) Mirroring_partner

func (*Mirroring_set_optionContext) Mirroring_witness

func (*Mirroring_set_optionContext) Partner_option

func (*Mirroring_set_optionContext) ToStringTree

func (s *Mirroring_set_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Mirroring_set_optionContext) Witness_option

type Mirroring_witnessContext

type Mirroring_witnessContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMirroring_witnessContext

func NewEmptyMirroring_witnessContext() *Mirroring_witnessContext

func NewMirroring_witnessContext

func NewMirroring_witnessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mirroring_witnessContext

func (*Mirroring_witnessContext) EnterRule

func (s *Mirroring_witnessContext) EnterRule(listener antlr.ParseTreeListener)

func (*Mirroring_witnessContext) ExitRule

func (s *Mirroring_witnessContext) ExitRule(listener antlr.ParseTreeListener)

func (*Mirroring_witnessContext) GetParser

func (s *Mirroring_witnessContext) GetParser() antlr.Parser

func (*Mirroring_witnessContext) GetRuleContext

func (s *Mirroring_witnessContext) GetRuleContext() antlr.RuleContext

func (*Mirroring_witnessContext) IsMirroring_witnessContext

func (*Mirroring_witnessContext) IsMirroring_witnessContext()

func (*Mirroring_witnessContext) ToStringTree

func (s *Mirroring_witnessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Mirroring_witnessContext) WITNESS

type Mixed_page_allocation_optionContext

type Mixed_page_allocation_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMixed_page_allocation_optionContext

func NewEmptyMixed_page_allocation_optionContext() *Mixed_page_allocation_optionContext

func NewMixed_page_allocation_optionContext

func NewMixed_page_allocation_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mixed_page_allocation_optionContext

func (*Mixed_page_allocation_optionContext) EnterRule

func (*Mixed_page_allocation_optionContext) ExitRule

func (*Mixed_page_allocation_optionContext) GetParser

func (*Mixed_page_allocation_optionContext) GetRuleContext

func (*Mixed_page_allocation_optionContext) IsMixed_page_allocation_optionContext

func (*Mixed_page_allocation_optionContext) IsMixed_page_allocation_optionContext()

func (*Mixed_page_allocation_optionContext) MIXED_PAGE_ALLOCATION

func (s *Mixed_page_allocation_optionContext) MIXED_PAGE_ALLOCATION() antlr.TerminalNode

func (*Mixed_page_allocation_optionContext) OFF

func (*Mixed_page_allocation_optionContext) ON

func (*Mixed_page_allocation_optionContext) ToStringTree

func (s *Mixed_page_allocation_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Modify_methodContext

type Modify_methodContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyModify_methodContext

func NewEmptyModify_methodContext() *Modify_methodContext

func NewModify_methodContext

func NewModify_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_methodContext

func (*Modify_methodContext) DOT

func (*Modify_methodContext) EnterRule

func (s *Modify_methodContext) EnterRule(listener antlr.ParseTreeListener)

func (*Modify_methodContext) ExitRule

func (s *Modify_methodContext) ExitRule(listener antlr.ParseTreeListener)

func (*Modify_methodContext) GetParser

func (s *Modify_methodContext) GetParser() antlr.Parser

func (*Modify_methodContext) GetRuleContext

func (s *Modify_methodContext) GetRuleContext() antlr.RuleContext

func (*Modify_methodContext) GetXml_dml

func (s *Modify_methodContext) GetXml_dml() antlr.Token

func (*Modify_methodContext) ID

func (*Modify_methodContext) IsModify_methodContext

func (*Modify_methodContext) IsModify_methodContext()

func (*Modify_methodContext) LOCAL_ID

func (s *Modify_methodContext) LOCAL_ID() antlr.TerminalNode

func (*Modify_methodContext) LR_BRACKET

func (s *Modify_methodContext) LR_BRACKET() antlr.TerminalNode

func (*Modify_methodContext) MODIFY

func (*Modify_methodContext) RR_BRACKET

func (s *Modify_methodContext) RR_BRACKET() antlr.TerminalNode

func (*Modify_methodContext) STRING

func (*Modify_methodContext) SetXml_dml

func (s *Modify_methodContext) SetXml_dml(v antlr.Token)

func (*Modify_methodContext) ToStringTree

func (s *Modify_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Multiple_local_file_startContext

type Multiple_local_file_startContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMultiple_local_file_startContext

func NewEmptyMultiple_local_file_startContext() *Multiple_local_file_startContext

func NewMultiple_local_file_startContext

func NewMultiple_local_file_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multiple_local_file_startContext

func (*Multiple_local_file_startContext) EnterRule

func (*Multiple_local_file_startContext) ExitRule

func (*Multiple_local_file_startContext) GetParser

func (*Multiple_local_file_startContext) GetRuleContext

func (*Multiple_local_file_startContext) IsMultiple_local_file_startContext

func (*Multiple_local_file_startContext) IsMultiple_local_file_startContext()

func (*Multiple_local_file_startContext) SINGLE_QUOTE

func (*Multiple_local_file_startContext) ToStringTree

func (s *Multiple_local_file_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Multiple_local_filesContext

type Multiple_local_filesContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMultiple_local_filesContext

func NewEmptyMultiple_local_filesContext() *Multiple_local_filesContext

func NewMultiple_local_filesContext

func NewMultiple_local_filesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multiple_local_filesContext

func (*Multiple_local_filesContext) COMMA

func (*Multiple_local_filesContext) EnterRule

func (s *Multiple_local_filesContext) EnterRule(listener antlr.ParseTreeListener)

func (*Multiple_local_filesContext) ExitRule

func (s *Multiple_local_filesContext) ExitRule(listener antlr.ParseTreeListener)

func (*Multiple_local_filesContext) GetParser

func (s *Multiple_local_filesContext) GetParser() antlr.Parser

func (*Multiple_local_filesContext) GetRuleContext

func (s *Multiple_local_filesContext) GetRuleContext() antlr.RuleContext

func (*Multiple_local_filesContext) IsMultiple_local_filesContext

func (*Multiple_local_filesContext) IsMultiple_local_filesContext()

func (*Multiple_local_filesContext) Local_file

func (*Multiple_local_filesContext) Multiple_local_file_start

func (s *Multiple_local_filesContext) Multiple_local_file_start() IMultiple_local_file_startContext

func (*Multiple_local_filesContext) SINGLE_QUOTE

func (*Multiple_local_filesContext) ToStringTree

func (s *Multiple_local_filesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NULLIFContext

type NULLIFContext struct {
	*Function_callContext
}

func NewNULLIFContext

func NewNULLIFContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NULLIFContext

func (*NULLIFContext) AllExpression

func (s *NULLIFContext) AllExpression() []IExpressionContext

func (*NULLIFContext) COMMA

func (s *NULLIFContext) COMMA() antlr.TerminalNode

func (*NULLIFContext) EnterRule

func (s *NULLIFContext) EnterRule(listener antlr.ParseTreeListener)

func (*NULLIFContext) ExitRule

func (s *NULLIFContext) ExitRule(listener antlr.ParseTreeListener)

func (*NULLIFContext) Expression

func (s *NULLIFContext) Expression(i int) IExpressionContext

func (*NULLIFContext) GetRuleContext

func (s *NULLIFContext) GetRuleContext() antlr.RuleContext

func (*NULLIFContext) LR_BRACKET

func (s *NULLIFContext) LR_BRACKET() antlr.TerminalNode

func (*NULLIFContext) NULLIF

func (s *NULLIFContext) NULLIF() antlr.TerminalNode

func (*NULLIFContext) RR_BRACKET

func (s *NULLIFContext) RR_BRACKET() antlr.TerminalNode

type Network_computerContext

type Network_computerContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNetwork_computerContext

func NewEmptyNetwork_computerContext() *Network_computerContext

func NewNetwork_computerContext

func NewNetwork_computerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Network_computerContext

func (*Network_computerContext) EnterRule

func (s *Network_computerContext) EnterRule(listener antlr.ParseTreeListener)

func (*Network_computerContext) ExitRule

func (s *Network_computerContext) ExitRule(listener antlr.ParseTreeListener)

func (*Network_computerContext) GetComputer_name

func (s *Network_computerContext) GetComputer_name() IIdContext

func (*Network_computerContext) GetParser

func (s *Network_computerContext) GetParser() antlr.Parser

func (*Network_computerContext) GetRuleContext

func (s *Network_computerContext) GetRuleContext() antlr.RuleContext

func (*Network_computerContext) Id

func (*Network_computerContext) IsNetwork_computerContext

func (*Network_computerContext) IsNetwork_computerContext()

func (*Network_computerContext) SetComputer_name

func (s *Network_computerContext) SetComputer_name(v IIdContext)

func (*Network_computerContext) ToStringTree

func (s *Network_computerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Network_file_shareContext

type Network_file_shareContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNetwork_file_shareContext

func NewEmptyNetwork_file_shareContext() *Network_file_shareContext

func NewNetwork_file_shareContext

func NewNetwork_file_shareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Network_file_shareContext

func (*Network_file_shareContext) EnterRule

func (s *Network_file_shareContext) EnterRule(listener antlr.ParseTreeListener)

func (*Network_file_shareContext) ExitRule

func (s *Network_file_shareContext) ExitRule(listener antlr.ParseTreeListener)

func (*Network_file_shareContext) File_path

func (*Network_file_shareContext) GetParser

func (s *Network_file_shareContext) GetParser() antlr.Parser

func (*Network_file_shareContext) GetRuleContext

func (s *Network_file_shareContext) GetRuleContext() antlr.RuleContext

func (*Network_file_shareContext) IsNetwork_file_shareContext

func (*Network_file_shareContext) IsNetwork_file_shareContext()

func (*Network_file_shareContext) Network_computer

func (*Network_file_shareContext) Network_file_start

func (s *Network_file_shareContext) Network_file_start() INetwork_file_startContext

func (*Network_file_shareContext) ToStringTree

func (s *Network_file_shareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Network_file_startContext

type Network_file_startContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNetwork_file_startContext

func NewEmptyNetwork_file_startContext() *Network_file_startContext

func NewNetwork_file_startContext

func NewNetwork_file_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Network_file_startContext

func (*Network_file_startContext) DOUBLE_BACK_SLASH

func (s *Network_file_startContext) DOUBLE_BACK_SLASH() antlr.TerminalNode

func (*Network_file_startContext) EnterRule

func (s *Network_file_startContext) EnterRule(listener antlr.ParseTreeListener)

func (*Network_file_startContext) ExitRule

func (s *Network_file_startContext) ExitRule(listener antlr.ParseTreeListener)

func (*Network_file_startContext) GetParser

func (s *Network_file_startContext) GetParser() antlr.Parser

func (*Network_file_startContext) GetRuleContext

func (s *Network_file_startContext) GetRuleContext() antlr.RuleContext

func (*Network_file_startContext) IsNetwork_file_startContext

func (*Network_file_startContext) IsNetwork_file_startContext()

func (*Network_file_startContext) ToStringTree

func (s *Network_file_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Nodes_methodContext

type Nodes_methodContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNodes_methodContext

func NewEmptyNodes_methodContext() *Nodes_methodContext

func NewNodes_methodContext

func NewNodes_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nodes_methodContext

func (*Nodes_methodContext) DOT

func (*Nodes_methodContext) EnterRule

func (s *Nodes_methodContext) EnterRule(listener antlr.ParseTreeListener)

func (*Nodes_methodContext) ExitRule

func (s *Nodes_methodContext) ExitRule(listener antlr.ParseTreeListener)

func (*Nodes_methodContext) GetParser

func (s *Nodes_methodContext) GetParser() antlr.Parser

func (*Nodes_methodContext) GetRuleContext

func (s *Nodes_methodContext) GetRuleContext() antlr.RuleContext

func (*Nodes_methodContext) GetXquery

func (s *Nodes_methodContext) GetXquery() antlr.Token

func (*Nodes_methodContext) ID

func (*Nodes_methodContext) IsNodes_methodContext

func (*Nodes_methodContext) IsNodes_methodContext()

func (*Nodes_methodContext) LOCAL_ID

func (s *Nodes_methodContext) LOCAL_ID() antlr.TerminalNode

func (*Nodes_methodContext) LR_BRACKET

func (s *Nodes_methodContext) LR_BRACKET() antlr.TerminalNode

func (*Nodes_methodContext) NODES

func (*Nodes_methodContext) RR_BRACKET

func (s *Nodes_methodContext) RR_BRACKET() antlr.TerminalNode

func (*Nodes_methodContext) STRING

func (*Nodes_methodContext) SetXquery

func (s *Nodes_methodContext) SetXquery(v antlr.Token)

func (*Nodes_methodContext) ToStringTree

func (s *Nodes_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Null_notnullContext

type Null_notnullContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNull_notnullContext

func NewEmptyNull_notnullContext() *Null_notnullContext

func NewNull_notnullContext

func NewNull_notnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Null_notnullContext

func (*Null_notnullContext) EnterRule

func (s *Null_notnullContext) EnterRule(listener antlr.ParseTreeListener)

func (*Null_notnullContext) ExitRule

func (s *Null_notnullContext) ExitRule(listener antlr.ParseTreeListener)

func (*Null_notnullContext) GetParser

func (s *Null_notnullContext) GetParser() antlr.Parser

func (*Null_notnullContext) GetRuleContext

func (s *Null_notnullContext) GetRuleContext() antlr.RuleContext

func (*Null_notnullContext) IsNull_notnullContext

func (*Null_notnullContext) IsNull_notnullContext()

func (*Null_notnullContext) NOT

func (*Null_notnullContext) NULL

func (*Null_notnullContext) ToStringTree

func (s *Null_notnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Null_or_defaultContext

type Null_or_defaultContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNull_or_defaultContext

func NewEmptyNull_or_defaultContext() *Null_or_defaultContext

func NewNull_or_defaultContext

func NewNull_or_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Null_or_defaultContext

func (*Null_or_defaultContext) Constant_expression

func (s *Null_or_defaultContext) Constant_expression() IConstant_expressionContext

func (*Null_or_defaultContext) DEFAULT

func (*Null_or_defaultContext) EnterRule

func (s *Null_or_defaultContext) EnterRule(listener antlr.ParseTreeListener)

func (*Null_or_defaultContext) ExitRule

func (s *Null_or_defaultContext) ExitRule(listener antlr.ParseTreeListener)

func (*Null_or_defaultContext) GetParser

func (s *Null_or_defaultContext) GetParser() antlr.Parser

func (*Null_or_defaultContext) GetRuleContext

func (s *Null_or_defaultContext) GetRuleContext() antlr.RuleContext

func (*Null_or_defaultContext) IsNull_or_defaultContext

func (*Null_or_defaultContext) IsNull_or_defaultContext()

func (*Null_or_defaultContext) Null_notnull

func (s *Null_or_defaultContext) Null_notnull() INull_notnullContext

func (*Null_or_defaultContext) ToStringTree

func (s *Null_or_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Null_or_defaultContext) VALUES

func (*Null_or_defaultContext) WITH

type On_deleteContext

type On_deleteContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOn_deleteContext

func NewEmptyOn_deleteContext() *On_deleteContext

func NewOn_deleteContext

func NewOn_deleteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_deleteContext

func (*On_deleteContext) ACTION

func (s *On_deleteContext) ACTION() antlr.TerminalNode

func (*On_deleteContext) CASCADE

func (s *On_deleteContext) CASCADE() antlr.TerminalNode

func (*On_deleteContext) DEFAULT

func (s *On_deleteContext) DEFAULT() antlr.TerminalNode

func (*On_deleteContext) DELETE

func (s *On_deleteContext) DELETE() antlr.TerminalNode

func (*On_deleteContext) EnterRule

func (s *On_deleteContext) EnterRule(listener antlr.ParseTreeListener)

func (*On_deleteContext) ExitRule

func (s *On_deleteContext) ExitRule(listener antlr.ParseTreeListener)

func (*On_deleteContext) GetParser

func (s *On_deleteContext) GetParser() antlr.Parser

func (*On_deleteContext) GetRuleContext

func (s *On_deleteContext) GetRuleContext() antlr.RuleContext

func (*On_deleteContext) IsOn_deleteContext

func (*On_deleteContext) IsOn_deleteContext()

func (*On_deleteContext) NO

func (*On_deleteContext) NULL

func (*On_deleteContext) ON

func (*On_deleteContext) SET

func (*On_deleteContext) ToStringTree

func (s *On_deleteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type On_offContext

type On_offContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOn_offContext

func NewEmptyOn_offContext() *On_offContext

func NewOn_offContext

func NewOn_offContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_offContext

func (*On_offContext) EnterRule

func (s *On_offContext) EnterRule(listener antlr.ParseTreeListener)

func (*On_offContext) ExitRule

func (s *On_offContext) ExitRule(listener antlr.ParseTreeListener)

func (*On_offContext) GetParser

func (s *On_offContext) GetParser() antlr.Parser

func (*On_offContext) GetRuleContext

func (s *On_offContext) GetRuleContext() antlr.RuleContext

func (*On_offContext) IsOn_offContext

func (*On_offContext) IsOn_offContext()

func (*On_offContext) OFF

func (s *On_offContext) OFF() antlr.TerminalNode

func (*On_offContext) ON

func (*On_offContext) ToStringTree

func (s *On_offContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type On_updateContext

type On_updateContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOn_updateContext

func NewEmptyOn_updateContext() *On_updateContext

func NewOn_updateContext

func NewOn_updateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_updateContext

func (*On_updateContext) ACTION

func (s *On_updateContext) ACTION() antlr.TerminalNode

func (*On_updateContext) CASCADE

func (s *On_updateContext) CASCADE() antlr.TerminalNode

func (*On_updateContext) DEFAULT

func (s *On_updateContext) DEFAULT() antlr.TerminalNode

func (*On_updateContext) EnterRule

func (s *On_updateContext) EnterRule(listener antlr.ParseTreeListener)

func (*On_updateContext) ExitRule

func (s *On_updateContext) ExitRule(listener antlr.ParseTreeListener)

func (*On_updateContext) GetParser

func (s *On_updateContext) GetParser() antlr.Parser

func (*On_updateContext) GetRuleContext

func (s *On_updateContext) GetRuleContext() antlr.RuleContext

func (*On_updateContext) IsOn_updateContext

func (*On_updateContext) IsOn_updateContext()

func (*On_updateContext) NO

func (*On_updateContext) NULL

func (*On_updateContext) ON

func (*On_updateContext) SET

func (*On_updateContext) ToStringTree

func (s *On_updateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*On_updateContext) UPDATE

func (s *On_updateContext) UPDATE() antlr.TerminalNode

type Open_keyContext

type Open_keyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOpen_keyContext

func NewEmptyOpen_keyContext() *Open_keyContext

func NewOpen_keyContext

func NewOpen_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_keyContext

func (*Open_keyContext) BY

func (*Open_keyContext) DECRYPTION

func (s *Open_keyContext) DECRYPTION() antlr.TerminalNode

func (*Open_keyContext) Decryption_mechanism

func (s *Open_keyContext) Decryption_mechanism() IDecryption_mechanismContext

func (*Open_keyContext) EQUAL

func (s *Open_keyContext) EQUAL() antlr.TerminalNode

func (*Open_keyContext) EnterRule

func (s *Open_keyContext) EnterRule(listener antlr.ParseTreeListener)

func (*Open_keyContext) ExitRule

func (s *Open_keyContext) ExitRule(listener antlr.ParseTreeListener)

func (*Open_keyContext) GetKey_name

func (s *Open_keyContext) GetKey_name() IIdContext

func (*Open_keyContext) GetParser

func (s *Open_keyContext) GetParser() antlr.Parser

func (*Open_keyContext) GetPassword

func (s *Open_keyContext) GetPassword() antlr.Token

func (*Open_keyContext) GetRuleContext

func (s *Open_keyContext) GetRuleContext() antlr.RuleContext

func (*Open_keyContext) Id

func (s *Open_keyContext) Id() IIdContext

func (*Open_keyContext) IsOpen_keyContext

func (*Open_keyContext) IsOpen_keyContext()

func (*Open_keyContext) KEY

func (*Open_keyContext) MASTER

func (s *Open_keyContext) MASTER() antlr.TerminalNode

func (*Open_keyContext) OPEN

func (*Open_keyContext) PASSWORD

func (s *Open_keyContext) PASSWORD() antlr.TerminalNode

func (*Open_keyContext) STRING

func (s *Open_keyContext) STRING() antlr.TerminalNode

func (*Open_keyContext) SYMMETRIC

func (s *Open_keyContext) SYMMETRIC() antlr.TerminalNode

func (*Open_keyContext) SetKey_name

func (s *Open_keyContext) SetKey_name(v IIdContext)

func (*Open_keyContext) SetPassword

func (s *Open_keyContext) SetPassword(v antlr.Token)

func (*Open_keyContext) ToStringTree

func (s *Open_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Open_xmlContext

type Open_xmlContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOpen_xmlContext

func NewEmptyOpen_xmlContext() *Open_xmlContext

func NewOpen_xmlContext

func NewOpen_xmlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_xmlContext

func (*Open_xmlContext) AllCOMMA

func (s *Open_xmlContext) AllCOMMA() []antlr.TerminalNode

func (*Open_xmlContext) AllExpression

func (s *Open_xmlContext) AllExpression() []IExpressionContext

func (*Open_xmlContext) AllLR_BRACKET

func (s *Open_xmlContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Open_xmlContext) AllRR_BRACKET

func (s *Open_xmlContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Open_xmlContext) COMMA

func (s *Open_xmlContext) COMMA(i int) antlr.TerminalNode

func (*Open_xmlContext) EnterRule

func (s *Open_xmlContext) EnterRule(listener antlr.ParseTreeListener)

func (*Open_xmlContext) ExitRule

func (s *Open_xmlContext) ExitRule(listener antlr.ParseTreeListener)

func (*Open_xmlContext) Expression

func (s *Open_xmlContext) Expression(i int) IExpressionContext

func (*Open_xmlContext) GetParser

func (s *Open_xmlContext) GetParser() antlr.Parser

func (*Open_xmlContext) GetRuleContext

func (s *Open_xmlContext) GetRuleContext() antlr.RuleContext

func (*Open_xmlContext) IsOpen_xmlContext

func (*Open_xmlContext) IsOpen_xmlContext()

func (*Open_xmlContext) LR_BRACKET

func (s *Open_xmlContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Open_xmlContext) OPENXML

func (s *Open_xmlContext) OPENXML() antlr.TerminalNode

func (*Open_xmlContext) RR_BRACKET

func (s *Open_xmlContext) RR_BRACKET(i int) antlr.TerminalNode

func (*Open_xmlContext) Schema_declaration

func (s *Open_xmlContext) Schema_declaration() ISchema_declarationContext

func (*Open_xmlContext) ToStringTree

func (s *Open_xmlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Open_xmlContext) WITH

type OpendatasourceContext

type OpendatasourceContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOpendatasourceContext

func NewEmptyOpendatasourceContext() *OpendatasourceContext

func NewOpendatasourceContext

func NewOpendatasourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpendatasourceContext

func (*OpendatasourceContext) AllDOT

func (*OpendatasourceContext) AllId

func (s *OpendatasourceContext) AllId() []IIdContext

func (*OpendatasourceContext) AllSTRING

func (s *OpendatasourceContext) AllSTRING() []antlr.TerminalNode

func (*OpendatasourceContext) COMMA

func (*OpendatasourceContext) DOT

func (*OpendatasourceContext) EnterRule

func (s *OpendatasourceContext) EnterRule(listener antlr.ParseTreeListener)

func (*OpendatasourceContext) ExitRule

func (s *OpendatasourceContext) ExitRule(listener antlr.ParseTreeListener)

func (*OpendatasourceContext) GetDatabase

func (s *OpendatasourceContext) GetDatabase() IIdContext

func (*OpendatasourceContext) GetInit

func (s *OpendatasourceContext) GetInit() antlr.Token

func (*OpendatasourceContext) GetParser

func (s *OpendatasourceContext) GetParser() antlr.Parser

func (*OpendatasourceContext) GetProvider

func (s *OpendatasourceContext) GetProvider() antlr.Token

func (*OpendatasourceContext) GetRuleContext

func (s *OpendatasourceContext) GetRuleContext() antlr.RuleContext

func (*OpendatasourceContext) GetScheme

func (s *OpendatasourceContext) GetScheme() IIdContext

func (*OpendatasourceContext) GetTable

func (s *OpendatasourceContext) GetTable() IIdContext

func (*OpendatasourceContext) Id

func (*OpendatasourceContext) IsOpendatasourceContext

func (*OpendatasourceContext) IsOpendatasourceContext()

func (*OpendatasourceContext) LR_BRACKET

func (s *OpendatasourceContext) LR_BRACKET() antlr.TerminalNode

func (*OpendatasourceContext) OPENDATASOURCE

func (s *OpendatasourceContext) OPENDATASOURCE() antlr.TerminalNode

func (*OpendatasourceContext) RR_BRACKET

func (s *OpendatasourceContext) RR_BRACKET() antlr.TerminalNode

func (*OpendatasourceContext) STRING

func (*OpendatasourceContext) SetDatabase

func (s *OpendatasourceContext) SetDatabase(v IIdContext)

func (*OpendatasourceContext) SetInit

func (s *OpendatasourceContext) SetInit(v antlr.Token)

func (*OpendatasourceContext) SetProvider

func (s *OpendatasourceContext) SetProvider(v antlr.Token)

func (*OpendatasourceContext) SetScheme

func (s *OpendatasourceContext) SetScheme(v IIdContext)

func (*OpendatasourceContext) SetTable

func (s *OpendatasourceContext) SetTable(v IIdContext)

func (*OpendatasourceContext) ToStringTree

func (s *OpendatasourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type OpenqueryContext

type OpenqueryContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOpenqueryContext

func NewEmptyOpenqueryContext() *OpenqueryContext

func NewOpenqueryContext

func NewOpenqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpenqueryContext

func (*OpenqueryContext) COMMA

func (s *OpenqueryContext) COMMA() antlr.TerminalNode

func (*OpenqueryContext) EnterRule

func (s *OpenqueryContext) EnterRule(listener antlr.ParseTreeListener)

func (*OpenqueryContext) ExitRule

func (s *OpenqueryContext) ExitRule(listener antlr.ParseTreeListener)

func (*OpenqueryContext) GetLinked_server

func (s *OpenqueryContext) GetLinked_server() IIdContext

func (*OpenqueryContext) GetParser

func (s *OpenqueryContext) GetParser() antlr.Parser

func (*OpenqueryContext) GetQuery

func (s *OpenqueryContext) GetQuery() antlr.Token

func (*OpenqueryContext) GetRuleContext

func (s *OpenqueryContext) GetRuleContext() antlr.RuleContext

func (*OpenqueryContext) Id

func (s *OpenqueryContext) Id() IIdContext

func (*OpenqueryContext) IsOpenqueryContext

func (*OpenqueryContext) IsOpenqueryContext()

func (*OpenqueryContext) LR_BRACKET

func (s *OpenqueryContext) LR_BRACKET() antlr.TerminalNode

func (*OpenqueryContext) OPENQUERY

func (s *OpenqueryContext) OPENQUERY() antlr.TerminalNode

func (*OpenqueryContext) RR_BRACKET

func (s *OpenqueryContext) RR_BRACKET() antlr.TerminalNode

func (*OpenqueryContext) STRING

func (s *OpenqueryContext) STRING() antlr.TerminalNode

func (*OpenqueryContext) SetLinked_server

func (s *OpenqueryContext) SetLinked_server(v IIdContext)

func (*OpenqueryContext) SetQuery

func (s *OpenqueryContext) SetQuery(v antlr.Token)

func (*OpenqueryContext) ToStringTree

func (s *OpenqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Optimize_for_argContext

type Optimize_for_argContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOptimize_for_argContext

func NewEmptyOptimize_for_argContext() *Optimize_for_argContext

func NewOptimize_for_argContext

func NewOptimize_for_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Optimize_for_argContext

func (*Optimize_for_argContext) Constant

func (*Optimize_for_argContext) EQUAL

func (*Optimize_for_argContext) EnterRule

func (s *Optimize_for_argContext) EnterRule(listener antlr.ParseTreeListener)

func (*Optimize_for_argContext) ExitRule

func (s *Optimize_for_argContext) ExitRule(listener antlr.ParseTreeListener)

func (*Optimize_for_argContext) GetParser

func (s *Optimize_for_argContext) GetParser() antlr.Parser

func (*Optimize_for_argContext) GetRuleContext

func (s *Optimize_for_argContext) GetRuleContext() antlr.RuleContext

func (*Optimize_for_argContext) IsOptimize_for_argContext

func (*Optimize_for_argContext) IsOptimize_for_argContext()

func (*Optimize_for_argContext) LOCAL_ID

func (*Optimize_for_argContext) NULL

func (*Optimize_for_argContext) ToStringTree

func (s *Optimize_for_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Optimize_for_argContext) UNKNOWN

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) AllCOMMA

func (s *OptionContext) AllCOMMA() []antlr.TerminalNode

func (*OptionContext) AllOptimize_for_arg

func (s *OptionContext) AllOptimize_for_arg() []IOptimize_for_argContext

func (*OptionContext) COMMA

func (s *OptionContext) COMMA(i int) antlr.TerminalNode

func (*OptionContext) CONCAT

func (s *OptionContext) CONCAT() antlr.TerminalNode

func (*OptionContext) DECIMAL

func (s *OptionContext) DECIMAL() antlr.TerminalNode

func (*OptionContext) EXPAND

func (s *OptionContext) EXPAND() antlr.TerminalNode

func (*OptionContext) EnterRule

func (s *OptionContext) EnterRule(listener antlr.ParseTreeListener)

func (*OptionContext) ExitRule

func (s *OptionContext) ExitRule(listener antlr.ParseTreeListener)

func (*OptionContext) FAST

func (s *OptionContext) FAST() antlr.TerminalNode

func (*OptionContext) FOR

func (s *OptionContext) FOR() antlr.TerminalNode

func (*OptionContext) FORCE

func (s *OptionContext) FORCE() antlr.TerminalNode

func (*OptionContext) FORCED

func (s *OptionContext) FORCED() antlr.TerminalNode

func (*OptionContext) GROUP

func (s *OptionContext) GROUP() antlr.TerminalNode

func (*OptionContext) GetNumber_of_processors

func (s *OptionContext) GetNumber_of_processors() antlr.Token

func (*OptionContext) GetNumber_recursion

func (s *OptionContext) GetNumber_recursion() antlr.Token

func (*OptionContext) GetNumber_rows

func (s *OptionContext) GetNumber_rows() antlr.Token

func (*OptionContext) GetParser

func (s *OptionContext) GetParser() antlr.Parser

func (*OptionContext) GetRuleContext

func (s *OptionContext) GetRuleContext() antlr.RuleContext

func (*OptionContext) HASH

func (s *OptionContext) HASH() antlr.TerminalNode

func (*OptionContext) IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX

func (s *OptionContext) IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX() antlr.TerminalNode

func (*OptionContext) IsOptionContext

func (*OptionContext) IsOptionContext()

func (*OptionContext) JOIN

func (s *OptionContext) JOIN() antlr.TerminalNode

func (*OptionContext) KEEP

func (s *OptionContext) KEEP() antlr.TerminalNode

func (*OptionContext) KEEPFIXED

func (s *OptionContext) KEEPFIXED() antlr.TerminalNode

func (*OptionContext) LOOP

func (s *OptionContext) LOOP() antlr.TerminalNode

func (*OptionContext) LR_BRACKET

func (s *OptionContext) LR_BRACKET() antlr.TerminalNode

func (*OptionContext) MAXDOP

func (s *OptionContext) MAXDOP() antlr.TerminalNode

func (*OptionContext) MAXRECURSION

func (s *OptionContext) MAXRECURSION() antlr.TerminalNode

func (*OptionContext) MERGE

func (s *OptionContext) MERGE() antlr.TerminalNode

func (*OptionContext) OPTIMIZE

func (s *OptionContext) OPTIMIZE() antlr.TerminalNode

func (*OptionContext) ORDER

func (s *OptionContext) ORDER() antlr.TerminalNode

func (*OptionContext) Optimize_for_arg

func (s *OptionContext) Optimize_for_arg(i int) IOptimize_for_argContext

func (*OptionContext) PARAMETERIZATION

func (s *OptionContext) PARAMETERIZATION() antlr.TerminalNode

func (*OptionContext) PLAN

func (s *OptionContext) PLAN() antlr.TerminalNode

func (*OptionContext) RECOMPILE

func (s *OptionContext) RECOMPILE() antlr.TerminalNode

func (*OptionContext) ROBUST

func (s *OptionContext) ROBUST() antlr.TerminalNode

func (*OptionContext) RR_BRACKET

func (s *OptionContext) RR_BRACKET() antlr.TerminalNode

func (*OptionContext) SIMPLE

func (s *OptionContext) SIMPLE() antlr.TerminalNode

func (*OptionContext) STRING

func (s *OptionContext) STRING() antlr.TerminalNode

func (*OptionContext) SetNumber_of_processors

func (s *OptionContext) SetNumber_of_processors(v antlr.Token)

func (*OptionContext) SetNumber_recursion

func (s *OptionContext) SetNumber_recursion(v antlr.Token)

func (*OptionContext) SetNumber_rows

func (s *OptionContext) SetNumber_rows(v antlr.Token)

func (*OptionContext) ToStringTree

func (s *OptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*OptionContext) UNION

func (s *OptionContext) UNION() antlr.TerminalNode

func (*OptionContext) UNKNOWN

func (s *OptionContext) UNKNOWN() antlr.TerminalNode

func (*OptionContext) USE

func (s *OptionContext) USE() antlr.TerminalNode

func (*OptionContext) VIEWS

func (s *OptionContext) VIEWS() antlr.TerminalNode

type Option_clauseContext

type Option_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOption_clauseContext

func NewEmptyOption_clauseContext() *Option_clauseContext

func NewOption_clauseContext

func NewOption_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Option_clauseContext

func (*Option_clauseContext) AllCOMMA

func (s *Option_clauseContext) AllCOMMA() []antlr.TerminalNode

func (*Option_clauseContext) AllOption

func (s *Option_clauseContext) AllOption() []IOptionContext

func (*Option_clauseContext) COMMA

func (*Option_clauseContext) EnterRule

func (s *Option_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Option_clauseContext) ExitRule

func (s *Option_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Option_clauseContext) GetParser

func (s *Option_clauseContext) GetParser() antlr.Parser

func (*Option_clauseContext) GetRuleContext

func (s *Option_clauseContext) GetRuleContext() antlr.RuleContext

func (*Option_clauseContext) IsOption_clauseContext

func (*Option_clauseContext) IsOption_clauseContext()

func (*Option_clauseContext) LR_BRACKET

func (s *Option_clauseContext) LR_BRACKET() antlr.TerminalNode

func (*Option_clauseContext) OPTION

func (*Option_clauseContext) Option

func (*Option_clauseContext) RR_BRACKET

func (s *Option_clauseContext) RR_BRACKET() antlr.TerminalNode

func (*Option_clauseContext) ToStringTree

func (s *Option_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Order_by_clauseContext

type Order_by_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOrder_by_clauseContext

func NewEmptyOrder_by_clauseContext() *Order_by_clauseContext

func NewOrder_by_clauseContext

func NewOrder_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_clauseContext

func (*Order_by_clauseContext) AllCOMMA

func (s *Order_by_clauseContext) AllCOMMA() []antlr.TerminalNode

func (*Order_by_clauseContext) AllExpression

func (s *Order_by_clauseContext) AllExpression() []IExpressionContext

func (*Order_by_clauseContext) AllOrder_by_expression

func (s *Order_by_clauseContext) AllOrder_by_expression() []IOrder_by_expressionContext

func (*Order_by_clauseContext) AllROW

func (*Order_by_clauseContext) AllROWS

func (s *Order_by_clauseContext) AllROWS() []antlr.TerminalNode

func (*Order_by_clauseContext) BY

func (*Order_by_clauseContext) COMMA

func (*Order_by_clauseContext) EnterRule

func (s *Order_by_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Order_by_clauseContext) ExitRule

func (s *Order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Order_by_clauseContext) Expression

func (*Order_by_clauseContext) FETCH

func (*Order_by_clauseContext) FIRST

func (*Order_by_clauseContext) GetParser

func (s *Order_by_clauseContext) GetParser() antlr.Parser

func (*Order_by_clauseContext) GetRuleContext

func (s *Order_by_clauseContext) GetRuleContext() antlr.RuleContext

func (*Order_by_clauseContext) IsOrder_by_clauseContext

func (*Order_by_clauseContext) IsOrder_by_clauseContext()

func (*Order_by_clauseContext) NEXT

func (*Order_by_clauseContext) OFFSET

func (*Order_by_clauseContext) ONLY

func (*Order_by_clauseContext) ORDER

func (*Order_by_clauseContext) Order_by_expression

func (s *Order_by_clauseContext) Order_by_expression(i int) IOrder_by_expressionContext

func (*Order_by_clauseContext) ROW

func (*Order_by_clauseContext) ROWS

func (*Order_by_clauseContext) ToStringTree

func (s *Order_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Order_by_expressionContext

type Order_by_expressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOrder_by_expressionContext

func NewEmptyOrder_by_expressionContext() *Order_by_expressionContext

func NewOrder_by_expressionContext

func NewOrder_by_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_expressionContext

func (*Order_by_expressionContext) ASC

func (*Order_by_expressionContext) DESC

func (*Order_by_expressionContext) EnterRule

func (s *Order_by_expressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Order_by_expressionContext) ExitRule

func (s *Order_by_expressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Order_by_expressionContext) Expression

func (*Order_by_expressionContext) GetParser

func (s *Order_by_expressionContext) GetParser() antlr.Parser

func (*Order_by_expressionContext) GetRuleContext

func (s *Order_by_expressionContext) GetRuleContext() antlr.RuleContext

func (*Order_by_expressionContext) IsOrder_by_expressionContext

func (*Order_by_expressionContext) IsOrder_by_expressionContext()

func (*Order_by_expressionContext) ToStringTree

func (s *Order_by_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Output_clauseContext

type Output_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOutput_clauseContext

func NewEmptyOutput_clauseContext() *Output_clauseContext

func NewOutput_clauseContext

func NewOutput_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Output_clauseContext

func (*Output_clauseContext) AllCOMMA

func (s *Output_clauseContext) AllCOMMA() []antlr.TerminalNode

func (*Output_clauseContext) AllOutput_dml_list_elem

func (s *Output_clauseContext) AllOutput_dml_list_elem() []IOutput_dml_list_elemContext

func (*Output_clauseContext) COMMA

func (*Output_clauseContext) Column_name_list

func (s *Output_clauseContext) Column_name_list() IColumn_name_listContext

func (*Output_clauseContext) EnterRule

func (s *Output_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Output_clauseContext) ExitRule

func (s *Output_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Output_clauseContext) GetParser

func (s *Output_clauseContext) GetParser() antlr.Parser

func (*Output_clauseContext) GetRuleContext

func (s *Output_clauseContext) GetRuleContext() antlr.RuleContext

func (*Output_clauseContext) INTO

func (*Output_clauseContext) IsOutput_clauseContext

func (*Output_clauseContext) IsOutput_clauseContext()

func (*Output_clauseContext) LOCAL_ID

func (s *Output_clauseContext) LOCAL_ID() antlr.TerminalNode

func (*Output_clauseContext) LR_BRACKET

func (s *Output_clauseContext) LR_BRACKET() antlr.TerminalNode

func (*Output_clauseContext) OUTPUT

func (*Output_clauseContext) Output_dml_list_elem

func (s *Output_clauseContext) Output_dml_list_elem(i int) IOutput_dml_list_elemContext

func (*Output_clauseContext) RR_BRACKET

func (s *Output_clauseContext) RR_BRACKET() antlr.TerminalNode

func (*Output_clauseContext) Table_name

func (s *Output_clauseContext) Table_name() ITable_nameContext

func (*Output_clauseContext) ToStringTree

func (s *Output_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Output_column_nameContext

type Output_column_nameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOutput_column_nameContext

func NewEmptyOutput_column_nameContext() *Output_column_nameContext

func NewOutput_column_nameContext

func NewOutput_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Output_column_nameContext

func (*Output_column_nameContext) DELETED

func (*Output_column_nameContext) DOLLAR_ACTION

func (s *Output_column_nameContext) DOLLAR_ACTION() antlr.TerminalNode

func (*Output_column_nameContext) DOT

func (*Output_column_nameContext) EnterRule

func (s *Output_column_nameContext) EnterRule(listener antlr.ParseTreeListener)

func (*Output_column_nameContext) ExitRule

func (s *Output_column_nameContext) ExitRule(listener antlr.ParseTreeListener)

func (*Output_column_nameContext) GetParser

func (s *Output_column_nameContext) GetParser() antlr.Parser

func (*Output_column_nameContext) GetRuleContext

func (s *Output_column_nameContext) GetRuleContext() antlr.RuleContext

func (*Output_column_nameContext) INSERTED

func (*Output_column_nameContext) Id

func (*Output_column_nameContext) IsOutput_column_nameContext

func (*Output_column_nameContext) IsOutput_column_nameContext()

func (*Output_column_nameContext) STAR

func (*Output_column_nameContext) Table_name

func (*Output_column_nameContext) ToStringTree

func (s *Output_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Output_dml_list_elemContext

type Output_dml_list_elemContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOutput_dml_list_elemContext

func NewEmptyOutput_dml_list_elemContext() *Output_dml_list_elemContext

func NewOutput_dml_list_elemContext

func NewOutput_dml_list_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Output_dml_list_elemContext

func (*Output_dml_list_elemContext) As_column_alias

func (*Output_dml_list_elemContext) EnterRule

func (s *Output_dml_list_elemContext) EnterRule(listener antlr.ParseTreeListener)

func (*Output_dml_list_elemContext) ExitRule

func (s *Output_dml_list_elemContext) ExitRule(listener antlr.ParseTreeListener)

func (*Output_dml_list_elemContext) Expression

func (*Output_dml_list_elemContext) GetParser

func (s *Output_dml_list_elemContext) GetParser() antlr.Parser

func (*Output_dml_list_elemContext) GetRuleContext

func (s *Output_dml_list_elemContext) GetRuleContext() antlr.RuleContext

func (*Output_dml_list_elemContext) IsOutput_dml_list_elemContext

func (*Output_dml_list_elemContext) IsOutput_dml_list_elemContext()

func (*Output_dml_list_elemContext) Output_column_name

func (*Output_dml_list_elemContext) ToStringTree

func (s *Output_dml_list_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Over_clauseContext

type Over_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyOver_clauseContext

func NewEmptyOver_clauseContext() *Over_clauseContext

func NewOver_clauseContext

func NewOver_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Over_clauseContext

func (*Over_clauseContext) BY

func (*Over_clauseContext) EnterRule

func (s *Over_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Over_clauseContext) ExitRule

func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Over_clauseContext) Expression_list

func (s *Over_clauseContext) Expression_list() IExpression_listContext

func (*Over_clauseContext) GetParser

func (s *Over_clauseContext) GetParser() antlr.Parser

func (*Over_clauseContext) GetRuleContext

func (s *Over_clauseContext) GetRuleContext() antlr.RuleContext

func (*Over_clauseContext) IsOver_clauseContext

func (*Over_clauseContext) IsOver_clauseContext()

func (*Over_clauseContext) LR_BRACKET

func (s *Over_clauseContext) LR_BRACKET() antlr.TerminalNode

func (*Over_clauseContext) OVER

func (*Over_clauseContext) Order_by_clause

func (s *Over_clauseContext) Order_by_clause() IOrder_by_clauseContext

func (*Over_clauseContext) PARTITION

func (s *Over_clauseContext) PARTITION() antlr.TerminalNode

func (*Over_clauseContext) RR_BRACKET

func (s *Over_clauseContext) RR_BRACKET() antlr.TerminalNode

func (*Over_clauseContext) Row_or_range_clause

func (s *Over_clauseContext) Row_or_range_clause() IRow_or_range_clauseContext

func (*Over_clauseContext) ToStringTree

func (s *Over_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Parameterization_optionContext

type Parameterization_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyParameterization_optionContext

func NewEmptyParameterization_optionContext() *Parameterization_optionContext

func NewParameterization_optionContext

func NewParameterization_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parameterization_optionContext

func (*Parameterization_optionContext) EnterRule

func (*Parameterization_optionContext) ExitRule

func (*Parameterization_optionContext) FORCED

func (*Parameterization_optionContext) GetParser

func (*Parameterization_optionContext) GetRuleContext

func (s *Parameterization_optionContext) GetRuleContext() antlr.RuleContext

func (*Parameterization_optionContext) IsParameterization_optionContext

func (*Parameterization_optionContext) IsParameterization_optionContext()

func (*Parameterization_optionContext) PARAMETERIZATION

func (s *Parameterization_optionContext) PARAMETERIZATION() antlr.TerminalNode

func (*Parameterization_optionContext) SIMPLE

func (*Parameterization_optionContext) ToStringTree

func (s *Parameterization_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Partner_optionContext

type Partner_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPartner_optionContext

func NewEmptyPartner_optionContext() *Partner_optionContext

func NewPartner_optionContext

func NewPartner_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partner_optionContext

func (*Partner_optionContext) DECIMAL

func (*Partner_optionContext) EnterRule

func (s *Partner_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Partner_optionContext) ExitRule

func (s *Partner_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Partner_optionContext) FAILOVER

func (*Partner_optionContext) FORCE_SERVICE_ALLOW_DATA_LOSS

func (s *Partner_optionContext) FORCE_SERVICE_ALLOW_DATA_LOSS() antlr.TerminalNode

func (*Partner_optionContext) FULL

func (*Partner_optionContext) GetParser

func (s *Partner_optionContext) GetParser() antlr.Parser

func (*Partner_optionContext) GetRuleContext

func (s *Partner_optionContext) GetRuleContext() antlr.RuleContext

func (*Partner_optionContext) IsPartner_optionContext

func (*Partner_optionContext) IsPartner_optionContext()

func (*Partner_optionContext) OFF

func (*Partner_optionContext) Partner_server

func (s *Partner_optionContext) Partner_server() IPartner_serverContext

func (*Partner_optionContext) RESUME

func (*Partner_optionContext) SAFETY

func (*Partner_optionContext) SUSPEND

func (*Partner_optionContext) TIMEOUT

func (*Partner_optionContext) ToStringTree

func (s *Partner_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Partner_optionContext) Witness_partner_equal

func (s *Partner_optionContext) Witness_partner_equal() IWitness_partner_equalContext

type Partner_serverContext

type Partner_serverContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPartner_serverContext

func NewEmptyPartner_serverContext() *Partner_serverContext

func NewPartner_serverContext

func NewPartner_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partner_serverContext

func (*Partner_serverContext) EnterRule

func (s *Partner_serverContext) EnterRule(listener antlr.ParseTreeListener)

func (*Partner_serverContext) ExitRule

func (s *Partner_serverContext) ExitRule(listener antlr.ParseTreeListener)

func (*Partner_serverContext) GetParser

func (s *Partner_serverContext) GetParser() antlr.Parser

func (*Partner_serverContext) GetRuleContext

func (s *Partner_serverContext) GetRuleContext() antlr.RuleContext

func (*Partner_serverContext) Host

func (*Partner_serverContext) IsPartner_serverContext

func (*Partner_serverContext) IsPartner_serverContext()

func (*Partner_serverContext) Mirroring_host_port_seperator

func (s *Partner_serverContext) Mirroring_host_port_seperator() IMirroring_host_port_seperatorContext

func (*Partner_serverContext) Partner_server_tcp_prefix

func (s *Partner_serverContext) Partner_server_tcp_prefix() IPartner_server_tcp_prefixContext

func (*Partner_serverContext) Port_number

func (s *Partner_serverContext) Port_number() IPort_numberContext

func (*Partner_serverContext) ToStringTree

func (s *Partner_serverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Partner_server_tcp_prefixContext

type Partner_server_tcp_prefixContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPartner_server_tcp_prefixContext

func NewEmptyPartner_server_tcp_prefixContext() *Partner_server_tcp_prefixContext

func NewPartner_server_tcp_prefixContext

func NewPartner_server_tcp_prefixContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partner_server_tcp_prefixContext

func (*Partner_server_tcp_prefixContext) COLON

func (*Partner_server_tcp_prefixContext) DOUBLE_FORWARD_SLASH

func (s *Partner_server_tcp_prefixContext) DOUBLE_FORWARD_SLASH() antlr.TerminalNode

func (*Partner_server_tcp_prefixContext) EnterRule

func (*Partner_server_tcp_prefixContext) ExitRule

func (*Partner_server_tcp_prefixContext) GetParser

func (*Partner_server_tcp_prefixContext) GetRuleContext

func (*Partner_server_tcp_prefixContext) IsPartner_server_tcp_prefixContext

func (*Partner_server_tcp_prefixContext) IsPartner_server_tcp_prefixContext()

func (*Partner_server_tcp_prefixContext) TCP

func (*Partner_server_tcp_prefixContext) ToStringTree

func (s *Partner_server_tcp_prefixContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Pivot_clauseContext

type Pivot_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPivot_clauseContext

func NewEmptyPivot_clauseContext() *Pivot_clauseContext

func NewPivot_clauseContext

func NewPivot_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_clauseContext

func (*Pivot_clauseContext) Aggregate_windowed_function

func (s *Pivot_clauseContext) Aggregate_windowed_function() IAggregate_windowed_functionContext

func (*Pivot_clauseContext) Column_alias_list

func (s *Pivot_clauseContext) Column_alias_list() IColumn_alias_listContext

func (*Pivot_clauseContext) EnterRule

func (s *Pivot_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Pivot_clauseContext) ExitRule

func (s *Pivot_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Pivot_clauseContext) FOR

func (*Pivot_clauseContext) Full_column_name

func (s *Pivot_clauseContext) Full_column_name() IFull_column_nameContext

func (*Pivot_clauseContext) GetParser

func (s *Pivot_clauseContext) GetParser() antlr.Parser

func (*Pivot_clauseContext) GetRuleContext

func (s *Pivot_clauseContext) GetRuleContext() antlr.RuleContext

func (*Pivot_clauseContext) IN

func (*Pivot_clauseContext) IsPivot_clauseContext

func (*Pivot_clauseContext) IsPivot_clauseContext()

func (*Pivot_clauseContext) LR_BRACKET

func (s *Pivot_clauseContext) LR_BRACKET() antlr.TerminalNode

func (*Pivot_clauseContext) RR_BRACKET

func (s *Pivot_clauseContext) RR_BRACKET() antlr.TerminalNode

func (*Pivot_clauseContext) ToStringTree

func (s *Pivot_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Port_numberContext

type Port_numberContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPort_numberContext

func NewEmptyPort_numberContext() *Port_numberContext

func NewPort_numberContext

func NewPort_numberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Port_numberContext

func (*Port_numberContext) DECIMAL

func (s *Port_numberContext) DECIMAL() antlr.TerminalNode

func (*Port_numberContext) EnterRule

func (s *Port_numberContext) EnterRule(listener antlr.ParseTreeListener)

func (*Port_numberContext) ExitRule

func (s *Port_numberContext) ExitRule(listener antlr.ParseTreeListener)

func (*Port_numberContext) GetParser

func (s *Port_numberContext) GetParser() antlr.Parser

func (*Port_numberContext) GetPort

func (s *Port_numberContext) GetPort() antlr.Token

func (*Port_numberContext) GetRuleContext

func (s *Port_numberContext) GetRuleContext() antlr.RuleContext

func (*Port_numberContext) IsPort_numberContext

func (*Port_numberContext) IsPort_numberContext()

func (*Port_numberContext) SetPort

func (s *Port_numberContext) SetPort(v antlr.Token)

func (*Port_numberContext) ToStringTree

func (s *Port_numberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

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) ALL

func (*PredicateContext) AND

func (*PredicateContext) ANY

func (*PredicateContext) AllExpression

func (s *PredicateContext) AllExpression() []IExpressionContext

func (*PredicateContext) BETWEEN

func (s *PredicateContext) BETWEEN() antlr.TerminalNode

func (*PredicateContext) Comparison_operator

func (s *PredicateContext) Comparison_operator() IComparison_operatorContext

func (*PredicateContext) ESCAPE

func (s *PredicateContext) ESCAPE() antlr.TerminalNode

func (*PredicateContext) EXISTS

func (s *PredicateContext) EXISTS() antlr.TerminalNode

func (*PredicateContext) EnterRule

func (s *PredicateContext) EnterRule(listener antlr.ParseTreeListener)

func (*PredicateContext) ExitRule

func (s *PredicateContext) ExitRule(listener antlr.ParseTreeListener)

func (*PredicateContext) Expression

func (s *PredicateContext) Expression(i int) IExpressionContext

func (*PredicateContext) Expression_list

func (s *PredicateContext) Expression_list() IExpression_listContext

func (*PredicateContext) GetParser

func (s *PredicateContext) GetParser() antlr.Parser

func (*PredicateContext) GetRuleContext

func (s *PredicateContext) GetRuleContext() antlr.RuleContext

func (*PredicateContext) IN

func (*PredicateContext) IS

func (*PredicateContext) IsPredicateContext

func (*PredicateContext) IsPredicateContext()

func (*PredicateContext) LIKE

func (*PredicateContext) LR_BRACKET

func (s *PredicateContext) LR_BRACKET() antlr.TerminalNode

func (*PredicateContext) NOT

func (*PredicateContext) Null_notnull

func (s *PredicateContext) Null_notnull() INull_notnullContext

func (*PredicateContext) RR_BRACKET

func (s *PredicateContext) RR_BRACKET() antlr.TerminalNode

func (*PredicateContext) SOME

func (*PredicateContext) Search_condition

func (s *PredicateContext) Search_condition() ISearch_conditionContext

func (*PredicateContext) Subquery

func (s *PredicateContext) Subquery() ISubqueryContext

func (*PredicateContext) ToStringTree

func (s *PredicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Primitive_expressionContext

type Primitive_expressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPrimitive_expressionContext

func NewEmptyPrimitive_expressionContext() *Primitive_expressionContext

func NewPrimitive_expressionContext

func NewPrimitive_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primitive_expressionContext

func (*Primitive_expressionContext) Constant

func (*Primitive_expressionContext) DEFAULT

func (*Primitive_expressionContext) EnterRule

func (s *Primitive_expressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Primitive_expressionContext) ExitRule

func (s *Primitive_expressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Primitive_expressionContext) GetParser

func (s *Primitive_expressionContext) GetParser() antlr.Parser

func (*Primitive_expressionContext) GetRuleContext

func (s *Primitive_expressionContext) GetRuleContext() antlr.RuleContext

func (*Primitive_expressionContext) IsPrimitive_expressionContext

func (*Primitive_expressionContext) IsPrimitive_expressionContext()

func (*Primitive_expressionContext) LOCAL_ID

func (*Primitive_expressionContext) NULL

func (*Primitive_expressionContext) ToStringTree

func (s *Primitive_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string
type Print_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPrint_statementContext

func NewEmptyPrint_statementContext() *Print_statementContext

func NewPrint_statementContext

func NewPrint_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Print_statementContext
func (s *Print_statementContext) AllCOMMA() []antlr.TerminalNode
func (s *Print_statementContext) AllLOCAL_ID() []antlr.TerminalNode
func (s *Print_statementContext) DOUBLE_QUOTE_ID() antlr.TerminalNode
func (s *Print_statementContext) EnterRule(listener antlr.ParseTreeListener)
func (s *Print_statementContext) ExitRule(listener antlr.ParseTreeListener)
func (s *Print_statementContext) GetParser() antlr.Parser
func (s *Print_statementContext) GetRuleContext() antlr.RuleContext
func (*Print_statementContext) IsPrint_statementContext()
func (s *Print_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Private_key_optionsContext

type Private_key_optionsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPrivate_key_optionsContext

func NewEmptyPrivate_key_optionsContext() *Private_key_optionsContext

func NewPrivate_key_optionsContext

func NewPrivate_key_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Private_key_optionsContext

func (*Private_key_optionsContext) AllEQUAL

func (*Private_key_optionsContext) AllSTRING

func (*Private_key_optionsContext) BINARY

func (*Private_key_optionsContext) BY

func (*Private_key_optionsContext) COMMA

func (*Private_key_optionsContext) DECRYPTION

func (*Private_key_optionsContext) ENCRYPTION

func (*Private_key_optionsContext) EQUAL

func (*Private_key_optionsContext) EnterRule

func (s *Private_key_optionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Private_key_optionsContext) ExitRule

func (s *Private_key_optionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Private_key_optionsContext) FILE

func (*Private_key_optionsContext) GetParser

func (s *Private_key_optionsContext) GetParser() antlr.Parser

func (*Private_key_optionsContext) GetPassword

func (s *Private_key_optionsContext) GetPassword() antlr.Token

func (*Private_key_optionsContext) GetPath

func (s *Private_key_optionsContext) GetPath() antlr.Token

func (*Private_key_optionsContext) GetRuleContext

func (s *Private_key_optionsContext) GetRuleContext() antlr.RuleContext

func (*Private_key_optionsContext) IsPrivate_key_optionsContext

func (*Private_key_optionsContext) IsPrivate_key_optionsContext()

func (*Private_key_optionsContext) PASSWORD

func (*Private_key_optionsContext) STRING

func (*Private_key_optionsContext) SetPassword

func (s *Private_key_optionsContext) SetPassword(v antlr.Token)

func (*Private_key_optionsContext) SetPath

func (s *Private_key_optionsContext) SetPath(v antlr.Token)

func (*Private_key_optionsContext) ToStringTree

func (s *Private_key_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Procedure_optionContext

type Procedure_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyProcedure_optionContext

func NewEmptyProcedure_optionContext() *Procedure_optionContext

func NewProcedure_optionContext

func NewProcedure_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_optionContext

func (*Procedure_optionContext) ENCRYPTION

func (s *Procedure_optionContext) ENCRYPTION() antlr.TerminalNode

func (*Procedure_optionContext) EnterRule

func (s *Procedure_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Procedure_optionContext) Execute_clause

func (s *Procedure_optionContext) Execute_clause() IExecute_clauseContext

func (*Procedure_optionContext) ExitRule

func (s *Procedure_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Procedure_optionContext) GetParser

func (s *Procedure_optionContext) GetParser() antlr.Parser

func (*Procedure_optionContext) GetRuleContext

func (s *Procedure_optionContext) GetRuleContext() antlr.RuleContext

func (*Procedure_optionContext) IsProcedure_optionContext

func (*Procedure_optionContext) IsProcedure_optionContext()

func (*Procedure_optionContext) RECOMPILE

func (*Procedure_optionContext) ToStringTree

func (s *Procedure_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Procedure_paramContext

type Procedure_paramContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyProcedure_paramContext

func NewEmptyProcedure_paramContext() *Procedure_paramContext

func NewProcedure_paramContext

func NewProcedure_paramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_paramContext

func (*Procedure_paramContext) AS

func (*Procedure_paramContext) DOT

func (*Procedure_paramContext) Data_type

func (*Procedure_paramContext) Default_value

func (s *Procedure_paramContext) Default_value() IDefault_valueContext

func (*Procedure_paramContext) EQUAL

func (*Procedure_paramContext) EnterRule

func (s *Procedure_paramContext) EnterRule(listener antlr.ParseTreeListener)

func (*Procedure_paramContext) ExitRule

func (s *Procedure_paramContext) ExitRule(listener antlr.ParseTreeListener)

func (*Procedure_paramContext) GetDefault_val

func (s *Procedure_paramContext) GetDefault_val() IDefault_valueContext

func (*Procedure_paramContext) GetParser

func (s *Procedure_paramContext) GetParser() antlr.Parser

func (*Procedure_paramContext) GetRuleContext

func (s *Procedure_paramContext) GetRuleContext() antlr.RuleContext

func (*Procedure_paramContext) Id

func (*Procedure_paramContext) IsProcedure_paramContext

func (*Procedure_paramContext) IsProcedure_paramContext()

func (*Procedure_paramContext) LOCAL_ID

func (*Procedure_paramContext) OUT

func (*Procedure_paramContext) OUTPUT

func (*Procedure_paramContext) READONLY

func (*Procedure_paramContext) SetDefault_val

func (s *Procedure_paramContext) SetDefault_val(v IDefault_valueContext)

func (*Procedure_paramContext) ToStringTree

func (s *Procedure_paramContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Procedure_paramContext) VARYING

type Query_expressionContext

type Query_expressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQuery_expressionContext

func NewEmptyQuery_expressionContext() *Query_expressionContext

func NewQuery_expressionContext

func NewQuery_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_expressionContext

func (*Query_expressionContext) AllSql_union

func (s *Query_expressionContext) AllSql_union() []ISql_unionContext

func (*Query_expressionContext) EnterRule

func (s *Query_expressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Query_expressionContext) ExitRule

func (s *Query_expressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Query_expressionContext) GetParser

func (s *Query_expressionContext) GetParser() antlr.Parser

func (*Query_expressionContext) GetRuleContext

func (s *Query_expressionContext) GetRuleContext() antlr.RuleContext

func (*Query_expressionContext) IsQuery_expressionContext

func (*Query_expressionContext) IsQuery_expressionContext()

func (*Query_expressionContext) LR_BRACKET

func (s *Query_expressionContext) LR_BRACKET() antlr.TerminalNode

func (*Query_expressionContext) Query_expression

func (s *Query_expressionContext) Query_expression() IQuery_expressionContext

func (*Query_expressionContext) Query_specification

func (s *Query_expressionContext) Query_specification() IQuery_specificationContext

func (*Query_expressionContext) RR_BRACKET

func (s *Query_expressionContext) RR_BRACKET() antlr.TerminalNode

func (*Query_expressionContext) Sql_union

func (*Query_expressionContext) ToStringTree

func (s *Query_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Query_methodContext

type Query_methodContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQuery_methodContext

func NewEmptyQuery_methodContext() *Query_methodContext

func NewQuery_methodContext

func NewQuery_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_methodContext

func (*Query_methodContext) AllDOT

func (s *Query_methodContext) AllDOT() []antlr.TerminalNode

func (*Query_methodContext) DOT

func (*Query_methodContext) EnterRule

func (s *Query_methodContext) EnterRule(listener antlr.ParseTreeListener)

func (*Query_methodContext) ExitRule

func (s *Query_methodContext) ExitRule(listener antlr.ParseTreeListener)

func (*Query_methodContext) Full_table_name

func (s *Query_methodContext) Full_table_name() IFull_table_nameContext

func (*Query_methodContext) GetParser

func (s *Query_methodContext) GetParser() antlr.Parser

func (*Query_methodContext) GetRuleContext

func (s *Query_methodContext) GetRuleContext() antlr.RuleContext

func (*Query_methodContext) GetXquery

func (s *Query_methodContext) GetXquery() antlr.Token

func (*Query_methodContext) ID

func (*Query_methodContext) IsQuery_methodContext

func (*Query_methodContext) IsQuery_methodContext()

func (*Query_methodContext) LOCAL_ID

func (s *Query_methodContext) LOCAL_ID() antlr.TerminalNode

func (*Query_methodContext) LR_BRACKET

func (s *Query_methodContext) LR_BRACKET() antlr.TerminalNode

func (*Query_methodContext) QUERY

func (*Query_methodContext) ROW

func (*Query_methodContext) RR_BRACKET

func (s *Query_methodContext) RR_BRACKET() antlr.TerminalNode

func (*Query_methodContext) STRING

func (*Query_methodContext) SetXquery

func (s *Query_methodContext) SetXquery(v antlr.Token)

func (*Query_methodContext) ToStringTree

func (s *Query_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Query_specificationContext

type Query_specificationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQuery_specificationContext

func NewEmptyQuery_specificationContext() *Query_specificationContext

func NewQuery_specificationContext

func NewQuery_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_specificationContext

func (*Query_specificationContext) ALL

func (*Query_specificationContext) AllALL

func (*Query_specificationContext) AllCOMMA

func (*Query_specificationContext) AllGroup_by_item

func (s *Query_specificationContext) AllGroup_by_item() []IGroup_by_itemContext

func (*Query_specificationContext) AllSearch_condition

func (s *Query_specificationContext) AllSearch_condition() []ISearch_conditionContext

func (*Query_specificationContext) BY

func (*Query_specificationContext) COMMA

func (*Query_specificationContext) DISTINCT

func (*Query_specificationContext) EnterRule

func (s *Query_specificationContext) EnterRule(listener antlr.ParseTreeListener)

func (*Query_specificationContext) ExitRule

func (s *Query_specificationContext) ExitRule(listener antlr.ParseTreeListener)

func (*Query_specificationContext) FROM

func (*Query_specificationContext) GROUP

func (*Query_specificationContext) GetHaving

func (*Query_specificationContext) GetParser

func (s *Query_specificationContext) GetParser() antlr.Parser

func (*Query_specificationContext) GetRuleContext

func (s *Query_specificationContext) GetRuleContext() antlr.RuleContext

func (*Query_specificationContext) GetWhere

func (*Query_specificationContext) Group_by_item

func (*Query_specificationContext) HAVING

func (*Query_specificationContext) INTO

func (*Query_specificationContext) IsQuery_specificationContext

func (*Query_specificationContext) IsQuery_specificationContext()

func (*Query_specificationContext) SELECT

func (*Query_specificationContext) Search_condition

func (*Query_specificationContext) Select_list

func (*Query_specificationContext) SetHaving

func (*Query_specificationContext) SetWhere

func (*Query_specificationContext) Table_name

func (*Query_specificationContext) Table_sources

func (*Query_specificationContext) ToStringTree

func (s *Query_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Query_specificationContext) Top_clause

func (*Query_specificationContext) WHERE

type Queue_actionContext

type Queue_actionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQueue_actionContext

func NewEmptyQueue_actionContext() *Queue_actionContext

func NewQueue_actionContext

func NewQueue_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Queue_actionContext

func (*Queue_actionContext) DEFAULT

func (s *Queue_actionContext) DEFAULT() antlr.TerminalNode

func (*Queue_actionContext) EQUAL

func (*Queue_actionContext) EnterRule

func (s *Queue_actionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Queue_actionContext) ExitRule

func (s *Queue_actionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Queue_actionContext) GetParser

func (s *Queue_actionContext) GetParser() antlr.Parser

func (*Queue_actionContext) GetRuleContext

func (s *Queue_actionContext) GetRuleContext() antlr.RuleContext

func (*Queue_actionContext) Id

func (*Queue_actionContext) IsQueue_actionContext

func (*Queue_actionContext) IsQueue_actionContext()

func (*Queue_actionContext) LOB_COMPACTION

func (s *Queue_actionContext) LOB_COMPACTION() antlr.TerminalNode

func (*Queue_actionContext) LR_BRACKET

func (s *Queue_actionContext) LR_BRACKET() antlr.TerminalNode

func (*Queue_actionContext) MOVE

func (*Queue_actionContext) OFF

func (*Queue_actionContext) ON

func (*Queue_actionContext) Queue_rebuild_options

func (s *Queue_actionContext) Queue_rebuild_options() IQueue_rebuild_optionsContext

func (*Queue_actionContext) REBUILD

func (s *Queue_actionContext) REBUILD() antlr.TerminalNode

func (*Queue_actionContext) REORGANIZE

func (s *Queue_actionContext) REORGANIZE() antlr.TerminalNode

func (*Queue_actionContext) RR_BRACKET

func (s *Queue_actionContext) RR_BRACKET() antlr.TerminalNode

func (*Queue_actionContext) TO

func (*Queue_actionContext) ToStringTree

func (s *Queue_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Queue_actionContext) WITH

type Queue_idContext

type Queue_idContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQueue_idContext

func NewEmptyQueue_idContext() *Queue_idContext

func NewQueue_idContext

func NewQueue_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Queue_idContext

func (*Queue_idContext) AllDOT

func (s *Queue_idContext) AllDOT() []antlr.TerminalNode

func (*Queue_idContext) AllId

func (s *Queue_idContext) AllId() []IIdContext

func (*Queue_idContext) DOT

func (*Queue_idContext) EnterRule

func (s *Queue_idContext) EnterRule(listener antlr.ParseTreeListener)

func (*Queue_idContext) ExitRule

func (s *Queue_idContext) ExitRule(listener antlr.ParseTreeListener)

func (*Queue_idContext) GetDatabase_name

func (s *Queue_idContext) GetDatabase_name() IIdContext

func (*Queue_idContext) GetName

func (s *Queue_idContext) GetName() IIdContext

func (*Queue_idContext) GetParser

func (s *Queue_idContext) GetParser() antlr.Parser

func (*Queue_idContext) GetRuleContext

func (s *Queue_idContext) GetRuleContext() antlr.RuleContext

func (*Queue_idContext) GetSchema_name

func (s *Queue_idContext) GetSchema_name() IIdContext

func (*Queue_idContext) Id

func (s *Queue_idContext) Id(i int) IIdContext

func (*Queue_idContext) IsQueue_idContext

func (*Queue_idContext) IsQueue_idContext()

func (*Queue_idContext) SetDatabase_name

func (s *Queue_idContext) SetDatabase_name(v IIdContext)

func (*Queue_idContext) SetName

func (s *Queue_idContext) SetName(v IIdContext)

func (*Queue_idContext) SetSchema_name

func (s *Queue_idContext) SetSchema_name(v IIdContext)

func (*Queue_idContext) ToStringTree

func (s *Queue_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Queue_rebuild_optionsContext

type Queue_rebuild_optionsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQueue_rebuild_optionsContext

func NewEmptyQueue_rebuild_optionsContext() *Queue_rebuild_optionsContext

func NewQueue_rebuild_optionsContext

func NewQueue_rebuild_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Queue_rebuild_optionsContext

func (*Queue_rebuild_optionsContext) DECIMAL

func (*Queue_rebuild_optionsContext) EQUAL

func (*Queue_rebuild_optionsContext) EnterRule

func (s *Queue_rebuild_optionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Queue_rebuild_optionsContext) ExitRule

func (*Queue_rebuild_optionsContext) GetParser

func (s *Queue_rebuild_optionsContext) GetParser() antlr.Parser

func (*Queue_rebuild_optionsContext) GetRuleContext

func (s *Queue_rebuild_optionsContext) GetRuleContext() antlr.RuleContext

func (*Queue_rebuild_optionsContext) IsQueue_rebuild_optionsContext

func (*Queue_rebuild_optionsContext) IsQueue_rebuild_optionsContext()

func (*Queue_rebuild_optionsContext) MAXDOP

func (*Queue_rebuild_optionsContext) ToStringTree

func (s *Queue_rebuild_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Queue_settingsContext

type Queue_settingsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyQueue_settingsContext

func NewEmptyQueue_settingsContext() *Queue_settingsContext

func NewQueue_settingsContext

func NewQueue_settingsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Queue_settingsContext

func (*Queue_settingsContext) ACTIVATION

func (s *Queue_settingsContext) ACTIVATION() antlr.TerminalNode

func (*Queue_settingsContext) AS

func (*Queue_settingsContext) AllCOMMA

func (s *Queue_settingsContext) AllCOMMA() []antlr.TerminalNode

func (*Queue_settingsContext) AllEQUAL

func (s *Queue_settingsContext) AllEQUAL() []antlr.TerminalNode

func (*Queue_settingsContext) AllLR_BRACKET

func (s *Queue_settingsContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Queue_settingsContext) AllOFF

func (*Queue_settingsContext) AllON

func (*Queue_settingsContext) AllRR_BRACKET

func (s *Queue_settingsContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Queue_settingsContext) AllSTATUS

func (s *Queue_settingsContext) AllSTATUS() []antlr.TerminalNode

func (*Queue_settingsContext) COMMA

func (*Queue_settingsContext) DECIMAL

func (*Queue_settingsContext) DROP

func (*Queue_settingsContext) EQUAL

func (*Queue_settingsContext) EXECUTE

func (*Queue_settingsContext) EnterRule

func (s *Queue_settingsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Queue_settingsContext) ExitRule

func (s *Queue_settingsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Queue_settingsContext) Func_proc_name_database_schema

func (s *Queue_settingsContext) Func_proc_name_database_schema() IFunc_proc_name_database_schemaContext

func (*Queue_settingsContext) GetMax_readers

func (s *Queue_settingsContext) GetMax_readers() antlr.Token

func (*Queue_settingsContext) GetParser

func (s *Queue_settingsContext) GetParser() antlr.Parser

func (*Queue_settingsContext) GetRuleContext

func (s *Queue_settingsContext) GetRuleContext() antlr.RuleContext

func (*Queue_settingsContext) GetUser_name

func (s *Queue_settingsContext) GetUser_name() antlr.Token

func (*Queue_settingsContext) IsQueue_settingsContext

func (*Queue_settingsContext) IsQueue_settingsContext()

func (*Queue_settingsContext) LR_BRACKET

func (s *Queue_settingsContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Queue_settingsContext) MAX_QUEUE_READERS

func (s *Queue_settingsContext) MAX_QUEUE_READERS() antlr.TerminalNode

func (*Queue_settingsContext) OFF

func (*Queue_settingsContext) ON

func (*Queue_settingsContext) OWNER

func (*Queue_settingsContext) POISON_MESSAGE_HANDLING

func (s *Queue_settingsContext) POISON_MESSAGE_HANDLING() antlr.TerminalNode

func (*Queue_settingsContext) PROCEDURE_NAME

func (s *Queue_settingsContext) PROCEDURE_NAME() antlr.TerminalNode

func (*Queue_settingsContext) RETENTION

func (s *Queue_settingsContext) RETENTION() antlr.TerminalNode

func (*Queue_settingsContext) RR_BRACKET

func (s *Queue_settingsContext) RR_BRACKET(i int) antlr.TerminalNode

func (*Queue_settingsContext) SELF

func (*Queue_settingsContext) STATUS

func (*Queue_settingsContext) STRING

func (*Queue_settingsContext) SetMax_readers

func (s *Queue_settingsContext) SetMax_readers(v antlr.Token)

func (*Queue_settingsContext) SetUser_name

func (s *Queue_settingsContext) SetUser_name(v antlr.Token)

func (*Queue_settingsContext) ToStringTree

func (s *Queue_settingsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Queue_settingsContext) WITH

type RANKING_WINDOWED_FUNCContext

type RANKING_WINDOWED_FUNCContext struct {
	*Function_callContext
}

func NewRANKING_WINDOWED_FUNCContext

func NewRANKING_WINDOWED_FUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *RANKING_WINDOWED_FUNCContext

func (*RANKING_WINDOWED_FUNCContext) EnterRule

func (s *RANKING_WINDOWED_FUNCContext) EnterRule(listener antlr.ParseTreeListener)

func (*RANKING_WINDOWED_FUNCContext) ExitRule

func (*RANKING_WINDOWED_FUNCContext) GetRuleContext

func (s *RANKING_WINDOWED_FUNCContext) GetRuleContext() antlr.RuleContext

func (*RANKING_WINDOWED_FUNCContext) Ranking_windowed_function

func (s *RANKING_WINDOWED_FUNCContext) Ranking_windowed_function() IRanking_windowed_functionContext

type Raiseerror_statementContext

type Raiseerror_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRaiseerror_statementContext

func NewEmptyRaiseerror_statementContext() *Raiseerror_statementContext

func NewRaiseerror_statementContext

func NewRaiseerror_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raiseerror_statementContext

func (*Raiseerror_statementContext) AllCOMMA

func (*Raiseerror_statementContext) AllConstant_LOCAL_ID

func (s *Raiseerror_statementContext) AllConstant_LOCAL_ID() []IConstant_LOCAL_IDContext

func (*Raiseerror_statementContext) AllDECIMAL

func (*Raiseerror_statementContext) AllLOCAL_ID

func (s *Raiseerror_statementContext) AllLOCAL_ID() []antlr.TerminalNode

func (*Raiseerror_statementContext) AllSTRING

func (*Raiseerror_statementContext) COMMA

func (*Raiseerror_statementContext) Constant_LOCAL_ID

func (*Raiseerror_statementContext) DECIMAL

func (*Raiseerror_statementContext) DOUBLE_QUOTE_ID

func (s *Raiseerror_statementContext) DOUBLE_QUOTE_ID() antlr.TerminalNode

func (*Raiseerror_statementContext) EnterRule

func (s *Raiseerror_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Raiseerror_statementContext) ExitRule

func (s *Raiseerror_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Raiseerror_statementContext) GetArgument

func (s *Raiseerror_statementContext) GetArgument() antlr.Token

func (*Raiseerror_statementContext) GetFormatstring

func (s *Raiseerror_statementContext) GetFormatstring() antlr.Token

func (*Raiseerror_statementContext) GetMsg

func (*Raiseerror_statementContext) GetParser

func (s *Raiseerror_statementContext) GetParser() antlr.Parser

func (*Raiseerror_statementContext) GetRuleContext

func (s *Raiseerror_statementContext) GetRuleContext() antlr.RuleContext

func (*Raiseerror_statementContext) GetSeverity

func (*Raiseerror_statementContext) GetState

func (*Raiseerror_statementContext) IsRaiseerror_statementContext

func (*Raiseerror_statementContext) IsRaiseerror_statementContext()

func (*Raiseerror_statementContext) LOCAL_ID

func (*Raiseerror_statementContext) LOG

func (*Raiseerror_statementContext) LR_BRACKET

func (*Raiseerror_statementContext) RAISERROR

func (*Raiseerror_statementContext) RR_BRACKET

func (*Raiseerror_statementContext) SEMI

func (*Raiseerror_statementContext) SETERROR

func (*Raiseerror_statementContext) STRING

func (*Raiseerror_statementContext) SetArgument

func (s *Raiseerror_statementContext) SetArgument(v antlr.Token)

func (*Raiseerror_statementContext) SetFormatstring

func (s *Raiseerror_statementContext) SetFormatstring(v antlr.Token)

func (*Raiseerror_statementContext) SetMsg

func (*Raiseerror_statementContext) SetSeverity

func (*Raiseerror_statementContext) SetState

func (*Raiseerror_statementContext) ToStringTree

func (s *Raiseerror_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Raiseerror_statementContext) WITH

type Ranking_windowed_functionContext

type Ranking_windowed_functionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRanking_windowed_functionContext

func NewEmptyRanking_windowed_functionContext() *Ranking_windowed_functionContext

func NewRanking_windowed_functionContext

func NewRanking_windowed_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ranking_windowed_functionContext

func (*Ranking_windowed_functionContext) DENSE_RANK

func (*Ranking_windowed_functionContext) EnterRule

func (*Ranking_windowed_functionContext) ExitRule

func (*Ranking_windowed_functionContext) Expression

func (*Ranking_windowed_functionContext) GetParser

func (*Ranking_windowed_functionContext) GetRuleContext

func (*Ranking_windowed_functionContext) IsRanking_windowed_functionContext

func (*Ranking_windowed_functionContext) IsRanking_windowed_functionContext()

func (*Ranking_windowed_functionContext) LR_BRACKET

func (*Ranking_windowed_functionContext) NTILE

func (*Ranking_windowed_functionContext) Over_clause

func (*Ranking_windowed_functionContext) RANK

func (*Ranking_windowed_functionContext) ROW_NUMBER

func (*Ranking_windowed_functionContext) RR_BRACKET

func (*Ranking_windowed_functionContext) ToStringTree

func (s *Ranking_windowed_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Receive_statementContext

type Receive_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyReceive_statementContext

func NewEmptyReceive_statementContext() *Receive_statementContext

func NewReceive_statementContext

func NewReceive_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Receive_statementContext

func (*Receive_statementContext) ALL

func (*Receive_statementContext) AllCOMMA

func (*Receive_statementContext) AllEQUAL

func (*Receive_statementContext) AllExpression

func (s *Receive_statementContext) AllExpression() []IExpressionContext

func (*Receive_statementContext) AllLOCAL_ID

func (s *Receive_statementContext) AllLOCAL_ID() []antlr.TerminalNode

func (*Receive_statementContext) COMMA

func (*Receive_statementContext) DISTINCT

func (*Receive_statementContext) EQUAL

func (*Receive_statementContext) EnterRule

func (s *Receive_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Receive_statementContext) ExitRule

func (s *Receive_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Receive_statementContext) Expression

func (*Receive_statementContext) FROM

func (*Receive_statementContext) Full_table_name

func (*Receive_statementContext) GetParser

func (s *Receive_statementContext) GetParser() antlr.Parser

func (*Receive_statementContext) GetRuleContext

func (s *Receive_statementContext) GetRuleContext() antlr.RuleContext

func (*Receive_statementContext) GetTable_variable

func (s *Receive_statementContext) GetTable_variable() IIdContext

func (*Receive_statementContext) GetWhere

func (*Receive_statementContext) INTO

func (*Receive_statementContext) Id

func (*Receive_statementContext) IsReceive_statementContext

func (*Receive_statementContext) IsReceive_statementContext()

func (*Receive_statementContext) LOCAL_ID

func (*Receive_statementContext) LR_BRACKET

func (*Receive_statementContext) RECEIVE

func (*Receive_statementContext) RR_BRACKET

func (*Receive_statementContext) STAR

func (*Receive_statementContext) Search_condition

func (s *Receive_statementContext) Search_condition() ISearch_conditionContext

func (*Receive_statementContext) SetTable_variable

func (s *Receive_statementContext) SetTable_variable(v IIdContext)

func (*Receive_statementContext) SetWhere

func (*Receive_statementContext) ToStringTree

func (s *Receive_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Receive_statementContext) Top_clause

func (*Receive_statementContext) WHERE

type Recovery_optionContext

type Recovery_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRecovery_optionContext

func NewEmptyRecovery_optionContext() *Recovery_optionContext

func NewRecovery_optionContext

func NewRecovery_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recovery_optionContext

func (*Recovery_optionContext) BULK_LOGGED

func (s *Recovery_optionContext) BULK_LOGGED() antlr.TerminalNode

func (*Recovery_optionContext) CHECKSUM

func (*Recovery_optionContext) EnterRule

func (s *Recovery_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Recovery_optionContext) ExitRule

func (s *Recovery_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Recovery_optionContext) FULL

func (*Recovery_optionContext) GetParser

func (s *Recovery_optionContext) GetParser() antlr.Parser

func (*Recovery_optionContext) GetRuleContext

func (s *Recovery_optionContext) GetRuleContext() antlr.RuleContext

func (*Recovery_optionContext) IsRecovery_optionContext

func (*Recovery_optionContext) IsRecovery_optionContext()

func (*Recovery_optionContext) NONE

func (*Recovery_optionContext) On_off

func (*Recovery_optionContext) PAGE_VERIFY

func (s *Recovery_optionContext) PAGE_VERIFY() antlr.TerminalNode

func (*Recovery_optionContext) RECOVERY

func (*Recovery_optionContext) SIMPLE

func (*Recovery_optionContext) TORN_PAGE_DETECTION

func (s *Recovery_optionContext) TORN_PAGE_DETECTION() antlr.TerminalNode

func (*Recovery_optionContext) ToStringTree

func (s *Recovery_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Return_statementContext

type Return_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyReturn_statementContext

func NewEmptyReturn_statementContext() *Return_statementContext

func NewReturn_statementContext

func NewReturn_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Return_statementContext

func (*Return_statementContext) EnterRule

func (s *Return_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Return_statementContext) ExitRule

func (s *Return_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Return_statementContext) Expression

func (*Return_statementContext) GetParser

func (s *Return_statementContext) GetParser() antlr.Parser

func (*Return_statementContext) GetRuleContext

func (s *Return_statementContext) GetRuleContext() antlr.RuleContext

func (*Return_statementContext) IsReturn_statementContext

func (*Return_statementContext) IsReturn_statementContext()

func (*Return_statementContext) RETURN

func (*Return_statementContext) SEMI

func (*Return_statementContext) ToStringTree

func (s *Return_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Row_or_range_clauseContext

type Row_or_range_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRow_or_range_clauseContext

func NewEmptyRow_or_range_clauseContext() *Row_or_range_clauseContext

func NewRow_or_range_clauseContext

func NewRow_or_range_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_or_range_clauseContext

func (*Row_or_range_clauseContext) EnterRule

func (s *Row_or_range_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Row_or_range_clauseContext) ExitRule

func (s *Row_or_range_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Row_or_range_clauseContext) GetParser

func (s *Row_or_range_clauseContext) GetParser() antlr.Parser

func (*Row_or_range_clauseContext) GetRuleContext

func (s *Row_or_range_clauseContext) GetRuleContext() antlr.RuleContext

func (*Row_or_range_clauseContext) IsRow_or_range_clauseContext

func (*Row_or_range_clauseContext) IsRow_or_range_clauseContext()

func (*Row_or_range_clauseContext) RANGE

func (*Row_or_range_clauseContext) ROWS

func (*Row_or_range_clauseContext) ToStringTree

func (s *Row_or_range_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Row_or_range_clauseContext) Window_frame_extent

type Rowset_functionContext

type Rowset_functionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRowset_functionContext

func NewEmptyRowset_functionContext() *Rowset_functionContext

func NewRowset_functionContext

func NewRowset_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rowset_functionContext

func (*Rowset_functionContext) AllBulk_option

func (s *Rowset_functionContext) AllBulk_option() []IBulk_optionContext

func (*Rowset_functionContext) AllCOMMA

func (s *Rowset_functionContext) AllCOMMA() []antlr.TerminalNode

func (*Rowset_functionContext) AllSTRING

func (s *Rowset_functionContext) AllSTRING() []antlr.TerminalNode

func (*Rowset_functionContext) BULK

func (*Rowset_functionContext) Bulk_option

func (*Rowset_functionContext) COMMA

func (*Rowset_functionContext) EnterRule

func (s *Rowset_functionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Rowset_functionContext) ExitRule

func (s *Rowset_functionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Rowset_functionContext) GetConnectionString

func (s *Rowset_functionContext) GetConnectionString() antlr.Token

func (*Rowset_functionContext) GetData_file

func (s *Rowset_functionContext) GetData_file() antlr.Token

func (*Rowset_functionContext) GetParser

func (s *Rowset_functionContext) GetParser() antlr.Parser

func (*Rowset_functionContext) GetProvider_name

func (s *Rowset_functionContext) GetProvider_name() antlr.Token

func (*Rowset_functionContext) GetRuleContext

func (s *Rowset_functionContext) GetRuleContext() antlr.RuleContext

func (*Rowset_functionContext) GetSql

func (s *Rowset_functionContext) GetSql() antlr.Token

func (*Rowset_functionContext) Id

func (*Rowset_functionContext) IsRowset_functionContext

func (*Rowset_functionContext) IsRowset_functionContext()

func (*Rowset_functionContext) LR_BRACKET

func (s *Rowset_functionContext) LR_BRACKET() antlr.TerminalNode

func (*Rowset_functionContext) OPENROWSET

func (s *Rowset_functionContext) OPENROWSET() antlr.TerminalNode

func (*Rowset_functionContext) RR_BRACKET

func (s *Rowset_functionContext) RR_BRACKET() antlr.TerminalNode

func (*Rowset_functionContext) STRING

func (*Rowset_functionContext) SetConnectionString

func (s *Rowset_functionContext) SetConnectionString(v antlr.Token)

func (*Rowset_functionContext) SetData_file

func (s *Rowset_functionContext) SetData_file(v antlr.Token)

func (*Rowset_functionContext) SetProvider_name

func (s *Rowset_functionContext) SetProvider_name(v antlr.Token)

func (*Rowset_functionContext) SetSql

func (s *Rowset_functionContext) SetSql(v antlr.Token)

func (*Rowset_functionContext) ToStringTree

func (s *Rowset_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Rowset_function_limitedContext

type Rowset_function_limitedContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRowset_function_limitedContext

func NewEmptyRowset_function_limitedContext() *Rowset_function_limitedContext

func NewRowset_function_limitedContext

func NewRowset_function_limitedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rowset_function_limitedContext

func (*Rowset_function_limitedContext) EnterRule

func (*Rowset_function_limitedContext) ExitRule

func (*Rowset_function_limitedContext) GetParser

func (*Rowset_function_limitedContext) GetRuleContext

func (s *Rowset_function_limitedContext) GetRuleContext() antlr.RuleContext

func (*Rowset_function_limitedContext) IsRowset_function_limitedContext

func (*Rowset_function_limitedContext) IsRowset_function_limitedContext()

func (*Rowset_function_limitedContext) Opendatasource

func (*Rowset_function_limitedContext) Openquery

func (*Rowset_function_limitedContext) ToStringTree

func (s *Rowset_function_limitedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SCALAR_FUNCTIONContext

type SCALAR_FUNCTIONContext struct {
	*Function_callContext
}

func NewSCALAR_FUNCTIONContext

func NewSCALAR_FUNCTIONContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SCALAR_FUNCTIONContext

func (*SCALAR_FUNCTIONContext) EnterRule

func (s *SCALAR_FUNCTIONContext) EnterRule(listener antlr.ParseTreeListener)

func (*SCALAR_FUNCTIONContext) ExitRule

func (s *SCALAR_FUNCTIONContext) ExitRule(listener antlr.ParseTreeListener)

func (*SCALAR_FUNCTIONContext) Expression_list

func (s *SCALAR_FUNCTIONContext) Expression_list() IExpression_listContext

func (*SCALAR_FUNCTIONContext) GetRuleContext

func (s *SCALAR_FUNCTIONContext) GetRuleContext() antlr.RuleContext

func (*SCALAR_FUNCTIONContext) LR_BRACKET

func (s *SCALAR_FUNCTIONContext) LR_BRACKET() antlr.TerminalNode

func (*SCALAR_FUNCTIONContext) RR_BRACKET

func (s *SCALAR_FUNCTIONContext) RR_BRACKET() antlr.TerminalNode

func (*SCALAR_FUNCTIONContext) Scalar_function_name

func (s *SCALAR_FUNCTIONContext) Scalar_function_name() IScalar_function_nameContext

type SESSION_USERContext

type SESSION_USERContext struct {
	*Function_callContext
}

func NewSESSION_USERContext

func NewSESSION_USERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SESSION_USERContext

func (*SESSION_USERContext) EnterRule

func (s *SESSION_USERContext) EnterRule(listener antlr.ParseTreeListener)

func (*SESSION_USERContext) ExitRule

func (s *SESSION_USERContext) ExitRule(listener antlr.ParseTreeListener)

func (*SESSION_USERContext) GetRuleContext

func (s *SESSION_USERContext) GetRuleContext() antlr.RuleContext

func (*SESSION_USERContext) SESSION_USER

func (s *SESSION_USERContext) SESSION_USER() antlr.TerminalNode

type STUFFContext

type STUFFContext struct {
	*Function_callContext
}

func NewSTUFFContext

func NewSTUFFContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *STUFFContext

func (*STUFFContext) AllCOMMA

func (s *STUFFContext) AllCOMMA() []antlr.TerminalNode

func (*STUFFContext) AllDECIMAL

func (s *STUFFContext) AllDECIMAL() []antlr.TerminalNode

func (*STUFFContext) AllExpression

func (s *STUFFContext) AllExpression() []IExpressionContext

func (*STUFFContext) COMMA

func (s *STUFFContext) COMMA(i int) antlr.TerminalNode

func (*STUFFContext) DECIMAL

func (s *STUFFContext) DECIMAL(i int) antlr.TerminalNode

func (*STUFFContext) EnterRule

func (s *STUFFContext) EnterRule(listener antlr.ParseTreeListener)

func (*STUFFContext) ExitRule

func (s *STUFFContext) ExitRule(listener antlr.ParseTreeListener)

func (*STUFFContext) Expression

func (s *STUFFContext) Expression(i int) IExpressionContext

func (*STUFFContext) GetRuleContext

func (s *STUFFContext) GetRuleContext() antlr.RuleContext

func (*STUFFContext) LR_BRACKET

func (s *STUFFContext) LR_BRACKET() antlr.TerminalNode

func (*STUFFContext) RR_BRACKET

func (s *STUFFContext) RR_BRACKET() antlr.TerminalNode

func (*STUFFContext) STUFF

func (s *STUFFContext) STUFF() antlr.TerminalNode

type SYSTEM_USERContext

type SYSTEM_USERContext struct {
	*Function_callContext
}

func NewSYSTEM_USERContext

func NewSYSTEM_USERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *SYSTEM_USERContext

func (*SYSTEM_USERContext) EnterRule

func (s *SYSTEM_USERContext) EnterRule(listener antlr.ParseTreeListener)

func (*SYSTEM_USERContext) ExitRule

func (s *SYSTEM_USERContext) ExitRule(listener antlr.ParseTreeListener)

func (*SYSTEM_USERContext) GetRuleContext

func (s *SYSTEM_USERContext) GetRuleContext() antlr.RuleContext

func (*SYSTEM_USERContext) SYSTEM_USER

func (s *SYSTEM_USERContext) SYSTEM_USER() antlr.TerminalNode

type Scalar_function_nameContext

type Scalar_function_nameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyScalar_function_nameContext

func NewEmptyScalar_function_nameContext() *Scalar_function_nameContext

func NewScalar_function_nameContext

func NewScalar_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Scalar_function_nameContext

func (*Scalar_function_nameContext) BINARY_CHECKSUM

func (s *Scalar_function_nameContext) BINARY_CHECKSUM() antlr.TerminalNode

func (*Scalar_function_nameContext) CHECKSUM

func (*Scalar_function_nameContext) EnterRule

func (s *Scalar_function_nameContext) EnterRule(listener antlr.ParseTreeListener)

func (*Scalar_function_nameContext) ExitRule

func (s *Scalar_function_nameContext) ExitRule(listener antlr.ParseTreeListener)

func (*Scalar_function_nameContext) Func_proc_name_server_database_schema

func (s *Scalar_function_nameContext) Func_proc_name_server_database_schema() IFunc_proc_name_server_database_schemaContext

func (*Scalar_function_nameContext) GetParser

func (s *Scalar_function_nameContext) GetParser() antlr.Parser

func (*Scalar_function_nameContext) GetRuleContext

func (s *Scalar_function_nameContext) GetRuleContext() antlr.RuleContext

func (*Scalar_function_nameContext) IsScalar_function_nameContext

func (*Scalar_function_nameContext) IsScalar_function_nameContext()

func (*Scalar_function_nameContext) LEFT

func (*Scalar_function_nameContext) RIGHT

func (*Scalar_function_nameContext) ToStringTree

func (s *Scalar_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Schema_declarationContext

type Schema_declarationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySchema_declarationContext

func NewEmptySchema_declarationContext() *Schema_declarationContext

func NewSchema_declarationContext

func NewSchema_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_declarationContext

func (*Schema_declarationContext) AllCOMMA

func (*Schema_declarationContext) AllColumn_declaration

func (s *Schema_declarationContext) AllColumn_declaration() []IColumn_declarationContext

func (*Schema_declarationContext) COMMA

func (*Schema_declarationContext) Column_declaration

func (s *Schema_declarationContext) Column_declaration(i int) IColumn_declarationContext

func (*Schema_declarationContext) EnterRule

func (s *Schema_declarationContext) EnterRule(listener antlr.ParseTreeListener)

func (*Schema_declarationContext) ExitRule

func (s *Schema_declarationContext) ExitRule(listener antlr.ParseTreeListener)

func (*Schema_declarationContext) GetParser

func (s *Schema_declarationContext) GetParser() antlr.Parser

func (*Schema_declarationContext) GetRuleContext

func (s *Schema_declarationContext) GetRuleContext() antlr.RuleContext

func (*Schema_declarationContext) IsSchema_declarationContext

func (*Schema_declarationContext) IsSchema_declarationContext()

func (*Schema_declarationContext) ToStringTree

func (s *Schema_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Search_conditionContext

type Search_conditionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySearch_conditionContext

func NewEmptySearch_conditionContext() *Search_conditionContext

func NewSearch_conditionContext

func NewSearch_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Search_conditionContext

func (*Search_conditionContext) AllOR

func (*Search_conditionContext) AllSearch_condition_and

func (s *Search_conditionContext) AllSearch_condition_and() []ISearch_condition_andContext

func (*Search_conditionContext) EnterRule

func (s *Search_conditionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Search_conditionContext) ExitRule

func (s *Search_conditionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Search_conditionContext) GetParser

func (s *Search_conditionContext) GetParser() antlr.Parser

func (*Search_conditionContext) GetRuleContext

func (s *Search_conditionContext) GetRuleContext() antlr.RuleContext

func (*Search_conditionContext) IsSearch_conditionContext

func (*Search_conditionContext) IsSearch_conditionContext()

func (*Search_conditionContext) OR

func (*Search_conditionContext) Search_condition_and

func (s *Search_conditionContext) Search_condition_and(i int) ISearch_condition_andContext

func (*Search_conditionContext) ToStringTree

func (s *Search_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Search_condition_andContext

type Search_condition_andContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySearch_condition_andContext

func NewEmptySearch_condition_andContext() *Search_condition_andContext

func NewSearch_condition_andContext

func NewSearch_condition_andContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Search_condition_andContext

func (*Search_condition_andContext) AND

func (*Search_condition_andContext) AllAND

func (*Search_condition_andContext) AllSearch_condition_not

func (s *Search_condition_andContext) AllSearch_condition_not() []ISearch_condition_notContext

func (*Search_condition_andContext) EnterRule

func (s *Search_condition_andContext) EnterRule(listener antlr.ParseTreeListener)

func (*Search_condition_andContext) ExitRule

func (s *Search_condition_andContext) ExitRule(listener antlr.ParseTreeListener)

func (*Search_condition_andContext) GetParser

func (s *Search_condition_andContext) GetParser() antlr.Parser

func (*Search_condition_andContext) GetRuleContext

func (s *Search_condition_andContext) GetRuleContext() antlr.RuleContext

func (*Search_condition_andContext) IsSearch_condition_andContext

func (*Search_condition_andContext) IsSearch_condition_andContext()

func (*Search_condition_andContext) Search_condition_not

func (*Search_condition_andContext) ToStringTree

func (s *Search_condition_andContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Search_condition_listContext

type Search_condition_listContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySearch_condition_listContext

func NewEmptySearch_condition_listContext() *Search_condition_listContext

func NewSearch_condition_listContext

func NewSearch_condition_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Search_condition_listContext

func (*Search_condition_listContext) AllCOMMA

func (*Search_condition_listContext) AllSearch_condition

func (s *Search_condition_listContext) AllSearch_condition() []ISearch_conditionContext

func (*Search_condition_listContext) COMMA

func (*Search_condition_listContext) EnterRule

func (s *Search_condition_listContext) EnterRule(listener antlr.ParseTreeListener)

func (*Search_condition_listContext) ExitRule

func (*Search_condition_listContext) GetParser

func (s *Search_condition_listContext) GetParser() antlr.Parser

func (*Search_condition_listContext) GetRuleContext

func (s *Search_condition_listContext) GetRuleContext() antlr.RuleContext

func (*Search_condition_listContext) IsSearch_condition_listContext

func (*Search_condition_listContext) IsSearch_condition_listContext()

func (*Search_condition_listContext) Search_condition

func (*Search_condition_listContext) ToStringTree

func (s *Search_condition_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Search_condition_notContext

type Search_condition_notContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySearch_condition_notContext

func NewEmptySearch_condition_notContext() *Search_condition_notContext

func NewSearch_condition_notContext

func NewSearch_condition_notContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Search_condition_notContext

func (*Search_condition_notContext) EnterRule

func (s *Search_condition_notContext) EnterRule(listener antlr.ParseTreeListener)

func (*Search_condition_notContext) ExitRule

func (s *Search_condition_notContext) ExitRule(listener antlr.ParseTreeListener)

func (*Search_condition_notContext) GetParser

func (s *Search_condition_notContext) GetParser() antlr.Parser

func (*Search_condition_notContext) GetRuleContext

func (s *Search_condition_notContext) GetRuleContext() antlr.RuleContext

func (*Search_condition_notContext) IsSearch_condition_notContext

func (*Search_condition_notContext) IsSearch_condition_notContext()

func (*Search_condition_notContext) NOT

func (*Search_condition_notContext) Predicate

func (*Search_condition_notContext) ToStringTree

func (s *Search_condition_notContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Security_statementContext

type Security_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySecurity_statementContext

func NewEmptySecurity_statementContext() *Security_statementContext

func NewSecurity_statementContext

func NewSecurity_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Security_statementContext

func (*Security_statementContext) ALL

func (*Security_statementContext) AS

func (*Security_statementContext) AllCOMMA

func (*Security_statementContext) AllGRANT

func (*Security_statementContext) AllId

func (*Security_statementContext) COMMA

func (*Security_statementContext) COOKIE

func (*Security_statementContext) Close_key

func (*Security_statementContext) Column_name_list

func (*Security_statementContext) Create_certificate

func (s *Security_statementContext) Create_certificate() ICreate_certificateContext

func (*Security_statementContext) Create_key

func (*Security_statementContext) EQUAL

func (*Security_statementContext) EnterRule

func (s *Security_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Security_statementContext) Execute_clause

func (*Security_statementContext) ExitRule

func (s *Security_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Security_statementContext) GRANT

func (*Security_statementContext) GetAs_principal

func (s *Security_statementContext) GetAs_principal() IIdContext

func (*Security_statementContext) GetOn_id

func (*Security_statementContext) GetParser

func (s *Security_statementContext) GetParser() antlr.Parser

func (*Security_statementContext) GetRuleContext

func (s *Security_statementContext) GetRuleContext() antlr.RuleContext

func (*Security_statementContext) GetTo_principal

func (s *Security_statementContext) GetTo_principal() []IIdContext

func (*Security_statementContext) Get_id

func (*Security_statementContext) Grant_permission

func (*Security_statementContext) Id

func (*Security_statementContext) IsSecurity_statementContext

func (*Security_statementContext) IsSecurity_statementContext()

func (*Security_statementContext) LOCAL_ID

func (*Security_statementContext) LR_BRACKET

func (*Security_statementContext) ON

func (*Security_statementContext) OPTION

func (*Security_statementContext) Open_key

func (*Security_statementContext) PRIVILEGES

func (*Security_statementContext) REVERT

func (*Security_statementContext) RR_BRACKET

func (*Security_statementContext) SEMI

func (*Security_statementContext) SetAs_principal

func (s *Security_statementContext) SetAs_principal(v IIdContext)

func (*Security_statementContext) SetOn_id

func (*Security_statementContext) SetTo_principal

func (s *Security_statementContext) SetTo_principal(v []IIdContext)

func (*Security_statementContext) Set_id

func (*Security_statementContext) TO

func (*Security_statementContext) Table_name

func (*Security_statementContext) ToStringTree

func (s *Security_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Security_statementContext) WITH

type Select_listContext

type Select_listContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySelect_listContext

func NewEmptySelect_listContext() *Select_listContext

func NewSelect_listContext

func NewSelect_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_listContext

func (*Select_listContext) AllCOMMA

func (s *Select_listContext) AllCOMMA() []antlr.TerminalNode

func (*Select_listContext) AllSelect_list_elem

func (s *Select_listContext) AllSelect_list_elem() []ISelect_list_elemContext

func (*Select_listContext) COMMA

func (*Select_listContext) EnterRule

func (s *Select_listContext) EnterRule(listener antlr.ParseTreeListener)

func (*Select_listContext) ExitRule

func (s *Select_listContext) ExitRule(listener antlr.ParseTreeListener)

func (*Select_listContext) GetParser

func (s *Select_listContext) GetParser() antlr.Parser

func (*Select_listContext) GetRuleContext

func (s *Select_listContext) GetRuleContext() antlr.RuleContext

func (*Select_listContext) IsSelect_listContext

func (*Select_listContext) IsSelect_listContext()

func (*Select_listContext) Select_list_elem

func (s *Select_listContext) Select_list_elem(i int) ISelect_list_elemContext

func (*Select_listContext) ToStringTree

func (s *Select_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Select_list_elemContext

type Select_list_elemContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySelect_list_elemContext

func NewEmptySelect_list_elemContext() *Select_list_elemContext

func NewSelect_list_elemContext

func NewSelect_list_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_list_elemContext

func (*Select_list_elemContext) Asterisk

func (*Select_list_elemContext) Column_elem

func (*Select_list_elemContext) EnterRule

func (s *Select_list_elemContext) EnterRule(listener antlr.ParseTreeListener)

func (*Select_list_elemContext) ExitRule

func (s *Select_list_elemContext) ExitRule(listener antlr.ParseTreeListener)

func (*Select_list_elemContext) Expression_elem

func (s *Select_list_elemContext) Expression_elem() IExpression_elemContext

func (*Select_list_elemContext) GetParser

func (s *Select_list_elemContext) GetParser() antlr.Parser

func (*Select_list_elemContext) GetRuleContext

func (s *Select_list_elemContext) GetRuleContext() antlr.RuleContext

func (*Select_list_elemContext) IsSelect_list_elemContext

func (*Select_list_elemContext) IsSelect_list_elemContext()

func (*Select_list_elemContext) ToStringTree

func (s *Select_list_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Select_list_elemContext) Udt_elem

type Select_statementContext

type Select_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySelect_statementContext

func NewEmptySelect_statementContext() *Select_statementContext

func NewSelect_statementContext

func NewSelect_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_statementContext

func (*Select_statementContext) EnterRule

func (s *Select_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Select_statementContext) ExitRule

func (s *Select_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Select_statementContext) For_clause

func (*Select_statementContext) GetParser

func (s *Select_statementContext) GetParser() antlr.Parser

func (*Select_statementContext) GetRuleContext

func (s *Select_statementContext) GetRuleContext() antlr.RuleContext

func (*Select_statementContext) IsSelect_statementContext

func (*Select_statementContext) IsSelect_statementContext()

func (*Select_statementContext) Option_clause

func (*Select_statementContext) Order_by_clause

func (s *Select_statementContext) Order_by_clause() IOrder_by_clauseContext

func (*Select_statementContext) Query_expression

func (s *Select_statementContext) Query_expression() IQuery_expressionContext

func (*Select_statementContext) SEMI

func (*Select_statementContext) ToStringTree

func (s *Select_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Select_statementContext) With_expression

func (s *Select_statementContext) With_expression() IWith_expressionContext

type Send_conversationContext

type Send_conversationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySend_conversationContext

func NewEmptySend_conversationContext() *Send_conversationContext

func NewSend_conversationContext

func NewSend_conversationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Send_conversationContext

func (*Send_conversationContext) AllLOCAL_ID

func (s *Send_conversationContext) AllLOCAL_ID() []antlr.TerminalNode

func (*Send_conversationContext) AllSTRING

func (s *Send_conversationContext) AllSTRING() []antlr.TerminalNode

func (*Send_conversationContext) CONVERSATION

func (s *Send_conversationContext) CONVERSATION() antlr.TerminalNode

func (*Send_conversationContext) EnterRule

func (s *Send_conversationContext) EnterRule(listener antlr.ParseTreeListener)

func (*Send_conversationContext) ExitRule

func (s *Send_conversationContext) ExitRule(listener antlr.ParseTreeListener)

func (*Send_conversationContext) Expression

func (*Send_conversationContext) GetConversation_handle

func (s *Send_conversationContext) GetConversation_handle() antlr.Token

func (*Send_conversationContext) GetMessage_body_expression

func (s *Send_conversationContext) GetMessage_body_expression() antlr.Token

func (*Send_conversationContext) GetMessage_type_name

func (s *Send_conversationContext) GetMessage_type_name() IExpressionContext

func (*Send_conversationContext) GetParser

func (s *Send_conversationContext) GetParser() antlr.Parser

func (*Send_conversationContext) GetRuleContext

func (s *Send_conversationContext) GetRuleContext() antlr.RuleContext

func (*Send_conversationContext) IsSend_conversationContext

func (*Send_conversationContext) IsSend_conversationContext()

func (*Send_conversationContext) LOCAL_ID

func (*Send_conversationContext) LR_BRACKET

func (*Send_conversationContext) MESSAGE

func (*Send_conversationContext) ON

func (*Send_conversationContext) RR_BRACKET

func (*Send_conversationContext) SEMI

func (*Send_conversationContext) SEND

func (*Send_conversationContext) STRING

func (*Send_conversationContext) SetConversation_handle

func (s *Send_conversationContext) SetConversation_handle(v antlr.Token)

func (*Send_conversationContext) SetMessage_body_expression

func (s *Send_conversationContext) SetMessage_body_expression(v antlr.Token)

func (*Send_conversationContext) SetMessage_type_name

func (s *Send_conversationContext) SetMessage_type_name(v IExpressionContext)

func (*Send_conversationContext) TYPE

func (*Send_conversationContext) ToStringTree

func (s *Send_conversationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Service_broker_optionContext

type Service_broker_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyService_broker_optionContext

func NewEmptyService_broker_optionContext() *Service_broker_optionContext

func NewService_broker_optionContext

func NewService_broker_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Service_broker_optionContext

func (*Service_broker_optionContext) DISABLE_BROKER

func (s *Service_broker_optionContext) DISABLE_BROKER() antlr.TerminalNode

func (*Service_broker_optionContext) ENABLE_BROKER

func (s *Service_broker_optionContext) ENABLE_BROKER() antlr.TerminalNode

func (*Service_broker_optionContext) ERROR_BROKER_CONVERSATIONS

func (s *Service_broker_optionContext) ERROR_BROKER_CONVERSATIONS() antlr.TerminalNode

func (*Service_broker_optionContext) EnterRule

func (s *Service_broker_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Service_broker_optionContext) ExitRule

func (*Service_broker_optionContext) GetParser

func (s *Service_broker_optionContext) GetParser() antlr.Parser

func (*Service_broker_optionContext) GetRuleContext

func (s *Service_broker_optionContext) GetRuleContext() antlr.RuleContext

func (*Service_broker_optionContext) HONOR_BROKER_PRIORITY

func (s *Service_broker_optionContext) HONOR_BROKER_PRIORITY() antlr.TerminalNode

func (*Service_broker_optionContext) IsService_broker_optionContext

func (*Service_broker_optionContext) IsService_broker_optionContext()

func (*Service_broker_optionContext) NEW_BROKER

func (*Service_broker_optionContext) On_off

func (*Service_broker_optionContext) ToStringTree

func (s *Service_broker_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Service_nameContext

type Service_nameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyService_nameContext

func NewEmptyService_nameContext() *Service_nameContext

func NewService_nameContext

func NewService_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Service_nameContext

func (*Service_nameContext) EnterRule

func (s *Service_nameContext) EnterRule(listener antlr.ParseTreeListener)

func (*Service_nameContext) ExitRule

func (s *Service_nameContext) ExitRule(listener antlr.ParseTreeListener)

func (*Service_nameContext) Expression

func (s *Service_nameContext) Expression() IExpressionContext

func (*Service_nameContext) GetParser

func (s *Service_nameContext) GetParser() antlr.Parser

func (*Service_nameContext) GetRuleContext

func (s *Service_nameContext) GetRuleContext() antlr.RuleContext

func (*Service_nameContext) Id

func (*Service_nameContext) IsService_nameContext

func (*Service_nameContext) IsService_nameContext()

func (*Service_nameContext) ToStringTree

func (s *Service_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Set_specialContext

type Set_specialContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySet_specialContext

func NewEmptySet_specialContext() *Set_specialContext

func NewSet_specialContext

func NewSet_specialContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_specialContext

func (*Set_specialContext) ANSI_NULLS

func (s *Set_specialContext) ANSI_NULLS() antlr.TerminalNode

func (*Set_specialContext) ANSI_PADDING

func (s *Set_specialContext) ANSI_PADDING() antlr.TerminalNode

func (*Set_specialContext) ANSI_WARNINGS

func (s *Set_specialContext) ANSI_WARNINGS() antlr.TerminalNode

func (*Set_specialContext) AllId

func (s *Set_specialContext) AllId() []IIdContext

func (*Set_specialContext) COMMITTED

func (s *Set_specialContext) COMMITTED() antlr.TerminalNode

func (*Set_specialContext) Constant_LOCAL_ID

func (s *Set_specialContext) Constant_LOCAL_ID() IConstant_LOCAL_IDContext

func (*Set_specialContext) DECIMAL

func (s *Set_specialContext) DECIMAL() antlr.TerminalNode

func (*Set_specialContext) EnterRule

func (s *Set_specialContext) EnterRule(listener antlr.ParseTreeListener)

func (*Set_specialContext) ExitRule

func (s *Set_specialContext) ExitRule(listener antlr.ParseTreeListener)

func (*Set_specialContext) GetParser

func (s *Set_specialContext) GetParser() antlr.Parser

func (*Set_specialContext) GetRuleContext

func (s *Set_specialContext) GetRuleContext() antlr.RuleContext

func (*Set_specialContext) IDENTITY_INSERT

func (s *Set_specialContext) IDENTITY_INSERT() antlr.TerminalNode

func (*Set_specialContext) ISOLATION

func (s *Set_specialContext) ISOLATION() antlr.TerminalNode

func (*Set_specialContext) Id

func (*Set_specialContext) IsSet_specialContext

func (*Set_specialContext) IsSet_specialContext()

func (*Set_specialContext) LEVEL

func (*Set_specialContext) Modify_method

func (s *Set_specialContext) Modify_method() IModify_methodContext

func (*Set_specialContext) On_off

func (s *Set_specialContext) On_off() IOn_offContext

func (*Set_specialContext) QUOTED_IDENTIFIER

func (s *Set_specialContext) QUOTED_IDENTIFIER() antlr.TerminalNode

func (*Set_specialContext) READ

func (*Set_specialContext) REPEATABLE

func (s *Set_specialContext) REPEATABLE() antlr.TerminalNode

func (*Set_specialContext) SEMI

func (*Set_specialContext) SERIALIZABLE

func (s *Set_specialContext) SERIALIZABLE() antlr.TerminalNode

func (*Set_specialContext) SET

func (*Set_specialContext) SNAPSHOT

func (s *Set_specialContext) SNAPSHOT() antlr.TerminalNode

func (*Set_specialContext) TRANSACTION

func (s *Set_specialContext) TRANSACTION() antlr.TerminalNode

func (*Set_specialContext) Table_name

func (s *Set_specialContext) Table_name() ITable_nameContext

func (*Set_specialContext) ToStringTree

func (s *Set_specialContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Set_specialContext) UNCOMMITTED

func (s *Set_specialContext) UNCOMMITTED() antlr.TerminalNode

type Set_statementContext

type Set_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySet_statementContext

func NewEmptySet_statementContext() *Set_statementContext

func NewSet_statementContext

func NewSet_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_statementContext

func (*Set_statementContext) Assignment_operator

func (s *Set_statementContext) Assignment_operator() IAssignment_operatorContext

func (*Set_statementContext) CURSOR

func (*Set_statementContext) Column_name_list

func (s *Set_statementContext) Column_name_list() IColumn_name_listContext

func (*Set_statementContext) DOT

func (*Set_statementContext) Declare_set_cursor_common

func (s *Set_statementContext) Declare_set_cursor_common() IDeclare_set_cursor_commonContext

func (*Set_statementContext) EQUAL

func (*Set_statementContext) EnterRule

func (s *Set_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Set_statementContext) ExitRule

func (s *Set_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Set_statementContext) Expression

func (s *Set_statementContext) Expression() IExpressionContext

func (*Set_statementContext) FOR

func (*Set_statementContext) GetMember_name

func (s *Set_statementContext) GetMember_name() IIdContext

func (*Set_statementContext) GetParser

func (s *Set_statementContext) GetParser() antlr.Parser

func (*Set_statementContext) GetRuleContext

func (s *Set_statementContext) GetRuleContext() antlr.RuleContext

func (*Set_statementContext) Id

func (*Set_statementContext) IsSet_statementContext

func (*Set_statementContext) IsSet_statementContext()

func (*Set_statementContext) LOCAL_ID

func (s *Set_statementContext) LOCAL_ID() antlr.TerminalNode

func (*Set_statementContext) OF

func (*Set_statementContext) ONLY

func (*Set_statementContext) READ

func (*Set_statementContext) SEMI

func (*Set_statementContext) SET

func (*Set_statementContext) SetMember_name

func (s *Set_statementContext) SetMember_name(v IIdContext)

func (*Set_statementContext) Set_special

func (s *Set_statementContext) Set_special() ISet_specialContext

func (*Set_statementContext) ToStringTree

func (s *Set_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Set_statementContext) UPDATE

type Setuser_statementContext

type Setuser_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySetuser_statementContext

func NewEmptySetuser_statementContext() *Setuser_statementContext

func NewSetuser_statementContext

func NewSetuser_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Setuser_statementContext

func (*Setuser_statementContext) EnterRule

func (s *Setuser_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Setuser_statementContext) ExitRule

func (s *Setuser_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Setuser_statementContext) GetParser

func (s *Setuser_statementContext) GetParser() antlr.Parser

func (*Setuser_statementContext) GetRuleContext

func (s *Setuser_statementContext) GetRuleContext() antlr.RuleContext

func (*Setuser_statementContext) GetUser

func (s *Setuser_statementContext) GetUser() antlr.Token

func (*Setuser_statementContext) IsSetuser_statementContext

func (*Setuser_statementContext) IsSetuser_statementContext()

func (*Setuser_statementContext) SETUSER

func (*Setuser_statementContext) STRING

func (*Setuser_statementContext) SetUser

func (s *Setuser_statementContext) SetUser(v antlr.Token)

func (*Setuser_statementContext) ToStringTree

func (s *Setuser_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SignContext

type SignContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySignContext

func NewEmptySignContext() *SignContext

func NewSignContext

func NewSignContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SignContext

func (*SignContext) EnterRule

func (s *SignContext) EnterRule(listener antlr.ParseTreeListener)

func (*SignContext) ExitRule

func (s *SignContext) ExitRule(listener antlr.ParseTreeListener)

func (*SignContext) GetParser

func (s *SignContext) GetParser() antlr.Parser

func (*SignContext) GetRuleContext

func (s *SignContext) GetRuleContext() antlr.RuleContext

func (*SignContext) IsSignContext

func (*SignContext) IsSignContext()

func (*SignContext) MINUS

func (s *SignContext) MINUS() antlr.TerminalNode

func (*SignContext) PLUS

func (s *SignContext) PLUS() antlr.TerminalNode

func (*SignContext) ToStringTree

func (s *SignContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Simple_idContext

type Simple_idContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySimple_idContext

func NewEmptySimple_idContext() *Simple_idContext

func NewSimple_idContext

func NewSimple_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_idContext

func (*Simple_idContext) ABSOLUTE

func (s *Simple_idContext) ABSOLUTE() antlr.TerminalNode

func (*Simple_idContext) ACCENT_SENSITIVITY

func (s *Simple_idContext) ACCENT_SENSITIVITY() antlr.TerminalNode

func (*Simple_idContext) ACTION

func (s *Simple_idContext) ACTION() antlr.TerminalNode

func (*Simple_idContext) ACTIVATION

func (s *Simple_idContext) ACTIVATION() antlr.TerminalNode

func (*Simple_idContext) ACTIVE

func (s *Simple_idContext) ACTIVE() antlr.TerminalNode

func (*Simple_idContext) ADDRESS

func (s *Simple_idContext) ADDRESS() antlr.TerminalNode

func (*Simple_idContext) AES_128

func (s *Simple_idContext) AES_128() antlr.TerminalNode

func (*Simple_idContext) AES_192

func (s *Simple_idContext) AES_192() antlr.TerminalNode

func (*Simple_idContext) AES_256

func (s *Simple_idContext) AES_256() antlr.TerminalNode

func (*Simple_idContext) AFFINITY

func (s *Simple_idContext) AFFINITY() antlr.TerminalNode

func (*Simple_idContext) AFTER

func (s *Simple_idContext) AFTER() antlr.TerminalNode

func (*Simple_idContext) AGGREGATE

func (s *Simple_idContext) AGGREGATE() antlr.TerminalNode

func (*Simple_idContext) ALGORITHM

func (s *Simple_idContext) ALGORITHM() antlr.TerminalNode

func (*Simple_idContext) ALLOWED

func (s *Simple_idContext) ALLOWED() antlr.TerminalNode

func (*Simple_idContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS

func (s *Simple_idContext) ALLOW_ENCRYPTED_VALUE_MODIFICATIONS() antlr.TerminalNode

func (*Simple_idContext) ALLOW_SNAPSHOT_ISOLATION

func (s *Simple_idContext) ALLOW_SNAPSHOT_ISOLATION() antlr.TerminalNode

func (*Simple_idContext) ANSI_NULLS

func (s *Simple_idContext) ANSI_NULLS() antlr.TerminalNode

func (*Simple_idContext) ANSI_NULL_DEFAULT

func (s *Simple_idContext) ANSI_NULL_DEFAULT() antlr.TerminalNode

func (*Simple_idContext) ANSI_PADDING

func (s *Simple_idContext) ANSI_PADDING() antlr.TerminalNode

func (*Simple_idContext) ANSI_WARNINGS

func (s *Simple_idContext) ANSI_WARNINGS() antlr.TerminalNode

func (*Simple_idContext) APPLICATION_LOG

func (s *Simple_idContext) APPLICATION_LOG() antlr.TerminalNode

func (*Simple_idContext) APPLY

func (s *Simple_idContext) APPLY() antlr.TerminalNode

func (*Simple_idContext) ARITHABORT

func (s *Simple_idContext) ARITHABORT() antlr.TerminalNode

func (*Simple_idContext) ASSEMBLY

func (s *Simple_idContext) ASSEMBLY() antlr.TerminalNode

func (*Simple_idContext) AUDIT

func (s *Simple_idContext) AUDIT() antlr.TerminalNode

func (*Simple_idContext) AUDIT_GUID

func (s *Simple_idContext) AUDIT_GUID() antlr.TerminalNode

func (*Simple_idContext) AUTO

func (*Simple_idContext) AUTO_CLEANUP

func (s *Simple_idContext) AUTO_CLEANUP() antlr.TerminalNode

func (*Simple_idContext) AUTO_CLOSE

func (s *Simple_idContext) AUTO_CLOSE() antlr.TerminalNode

func (*Simple_idContext) AUTO_CREATE_STATISTICS

func (s *Simple_idContext) AUTO_CREATE_STATISTICS() antlr.TerminalNode

func (*Simple_idContext) AUTO_SHRINK

func (s *Simple_idContext) AUTO_SHRINK() antlr.TerminalNode

func (*Simple_idContext) AUTO_UPDATE_STATISTICS

func (s *Simple_idContext) AUTO_UPDATE_STATISTICS() antlr.TerminalNode

func (*Simple_idContext) AUTO_UPDATE_STATISTICS_ASYNC

func (s *Simple_idContext) AUTO_UPDATE_STATISTICS_ASYNC() antlr.TerminalNode

func (*Simple_idContext) AVAILABILITY

func (s *Simple_idContext) AVAILABILITY() antlr.TerminalNode

func (*Simple_idContext) AVG

func (*Simple_idContext) BACKUP_PRIORITY

func (s *Simple_idContext) BACKUP_PRIORITY() antlr.TerminalNode

func (*Simple_idContext) BEGIN_DIALOG

func (s *Simple_idContext) BEGIN_DIALOG() antlr.TerminalNode

func (*Simple_idContext) BIGINT

func (s *Simple_idContext) BIGINT() antlr.TerminalNode

func (*Simple_idContext) BINARY_BASE64

func (s *Simple_idContext) BINARY_BASE64() antlr.TerminalNode

func (*Simple_idContext) BINARY_CHECKSUM

func (s *Simple_idContext) BINARY_CHECKSUM() antlr.TerminalNode

func (*Simple_idContext) BINDING

func (s *Simple_idContext) BINDING() antlr.TerminalNode

func (*Simple_idContext) BLOB_STORAGE

func (s *Simple_idContext) BLOB_STORAGE() antlr.TerminalNode

func (*Simple_idContext) BROKER

func (s *Simple_idContext) BROKER() antlr.TerminalNode

func (*Simple_idContext) BROKER_INSTANCE

func (s *Simple_idContext) BROKER_INSTANCE() antlr.TerminalNode

func (*Simple_idContext) BULK_LOGGED

func (s *Simple_idContext) BULK_LOGGED() antlr.TerminalNode

func (*Simple_idContext) CALLED

func (s *Simple_idContext) CALLED() antlr.TerminalNode

func (*Simple_idContext) CALLER

func (s *Simple_idContext) CALLER() antlr.TerminalNode

func (*Simple_idContext) CAP_CPU_PERCENT

func (s *Simple_idContext) CAP_CPU_PERCENT() antlr.TerminalNode

func (*Simple_idContext) CAST

func (*Simple_idContext) CATALOG

func (s *Simple_idContext) CATALOG() antlr.TerminalNode

func (*Simple_idContext) CATCH

func (s *Simple_idContext) CATCH() antlr.TerminalNode

func (*Simple_idContext) CHANGE_RETENTION

func (s *Simple_idContext) CHANGE_RETENTION() antlr.TerminalNode

func (*Simple_idContext) CHANGE_TRACKING

func (s *Simple_idContext) CHANGE_TRACKING() antlr.TerminalNode

func (*Simple_idContext) CHECKSUM

func (s *Simple_idContext) CHECKSUM() antlr.TerminalNode

func (*Simple_idContext) CHECKSUM_AGG

func (s *Simple_idContext) CHECKSUM_AGG() antlr.TerminalNode

func (*Simple_idContext) CLEANUP

func (s *Simple_idContext) CLEANUP() antlr.TerminalNode

func (*Simple_idContext) COLLECTION

func (s *Simple_idContext) COLLECTION() antlr.TerminalNode

func (*Simple_idContext) COLUMN_MASTER_KEY

func (s *Simple_idContext) COLUMN_MASTER_KEY() antlr.TerminalNode

func (*Simple_idContext) COMMITTED

func (s *Simple_idContext) COMMITTED() antlr.TerminalNode

func (*Simple_idContext) COMPATIBILITY_LEVEL

func (s *Simple_idContext) COMPATIBILITY_LEVEL() antlr.TerminalNode

func (*Simple_idContext) CONCAT

func (s *Simple_idContext) CONCAT() antlr.TerminalNode

func (*Simple_idContext) CONCAT_NULL_YIELDS_NULL

func (s *Simple_idContext) CONCAT_NULL_YIELDS_NULL() antlr.TerminalNode

func (*Simple_idContext) CONTENT

func (s *Simple_idContext) CONTENT() antlr.TerminalNode

func (*Simple_idContext) CONTROL

func (s *Simple_idContext) CONTROL() antlr.TerminalNode

func (*Simple_idContext) COOKIE

func (s *Simple_idContext) COOKIE() antlr.TerminalNode

func (*Simple_idContext) COUNT

func (s *Simple_idContext) COUNT() antlr.TerminalNode

func (*Simple_idContext) COUNTER

func (s *Simple_idContext) COUNTER() antlr.TerminalNode

func (*Simple_idContext) COUNT_BIG

func (s *Simple_idContext) COUNT_BIG() antlr.TerminalNode

func (*Simple_idContext) CPU

func (*Simple_idContext) CREATE_NEW

func (s *Simple_idContext) CREATE_NEW() antlr.TerminalNode

func (*Simple_idContext) CREATION_DISPOSITION

func (s *Simple_idContext) CREATION_DISPOSITION() antlr.TerminalNode

func (*Simple_idContext) CREDENTIAL

func (s *Simple_idContext) CREDENTIAL() antlr.TerminalNode

func (*Simple_idContext) CRYPTOGRAPHIC

func (s *Simple_idContext) CRYPTOGRAPHIC() antlr.TerminalNode

func (*Simple_idContext) CURSOR_CLOSE_ON_COMMIT

func (s *Simple_idContext) CURSOR_CLOSE_ON_COMMIT() antlr.TerminalNode

func (*Simple_idContext) CURSOR_DEFAULT

func (s *Simple_idContext) CURSOR_DEFAULT() antlr.TerminalNode

func (*Simple_idContext) DATA_COMPRESSION

func (s *Simple_idContext) DATA_COMPRESSION() antlr.TerminalNode

func (*Simple_idContext) DATEADD

func (s *Simple_idContext) DATEADD() antlr.TerminalNode

func (*Simple_idContext) DATEDIFF

func (s *Simple_idContext) DATEDIFF() antlr.TerminalNode

func (*Simple_idContext) DATENAME

func (s *Simple_idContext) DATENAME() antlr.TerminalNode

func (*Simple_idContext) DATEPART

func (s *Simple_idContext) DATEPART() antlr.TerminalNode

func (*Simple_idContext) DATE_CORRELATION_OPTIMIZATION

func (s *Simple_idContext) DATE_CORRELATION_OPTIMIZATION() antlr.TerminalNode

func (*Simple_idContext) DAYS

func (*Simple_idContext) DB_CHAINING

func (s *Simple_idContext) DB_CHAINING() antlr.TerminalNode

func (*Simple_idContext) DB_FAILOVER

func (s *Simple_idContext) DB_FAILOVER() antlr.TerminalNode

func (*Simple_idContext) DECRYPTION

func (s *Simple_idContext) DECRYPTION() antlr.TerminalNode

func (*Simple_idContext) DEFAULT_DOUBLE_QUOTE

func (s *Simple_idContext) DEFAULT_DOUBLE_QUOTE() antlr.TerminalNode

func (*Simple_idContext) DEFAULT_FULLTEXT_LANGUAGE

func (s *Simple_idContext) DEFAULT_FULLTEXT_LANGUAGE() antlr.TerminalNode

func (*Simple_idContext) DEFAULT_LANGUAGE

func (s *Simple_idContext) DEFAULT_LANGUAGE() antlr.TerminalNode

func (*Simple_idContext) DELAY

func (s *Simple_idContext) DELAY() antlr.TerminalNode

func (*Simple_idContext) DELAYED_DURABILITY

func (s *Simple_idContext) DELAYED_DURABILITY() antlr.TerminalNode

func (*Simple_idContext) DELETED

func (s *Simple_idContext) DELETED() antlr.TerminalNode

func (*Simple_idContext) DENSE_RANK

func (s *Simple_idContext) DENSE_RANK() antlr.TerminalNode

func (*Simple_idContext) DEPENDENTS

func (s *Simple_idContext) DEPENDENTS() antlr.TerminalNode

func (*Simple_idContext) DES

func (*Simple_idContext) DESCRIPTION

func (s *Simple_idContext) DESCRIPTION() antlr.TerminalNode

func (*Simple_idContext) DESX

func (*Simple_idContext) DHCP

func (*Simple_idContext) DIALOG

func (s *Simple_idContext) DIALOG() antlr.TerminalNode

func (*Simple_idContext) DIRECTORY_NAME

func (s *Simple_idContext) DIRECTORY_NAME() antlr.TerminalNode

func (*Simple_idContext) DISABLE

func (s *Simple_idContext) DISABLE() antlr.TerminalNode

func (*Simple_idContext) DISABLED

func (s *Simple_idContext) DISABLED() antlr.TerminalNode

func (*Simple_idContext) DISABLE_BROKER

func (s *Simple_idContext) DISABLE_BROKER() antlr.TerminalNode

func (*Simple_idContext) DISK_DRIVE

func (s *Simple_idContext) DISK_DRIVE() antlr.TerminalNode

func (*Simple_idContext) DOCUMENT

func (s *Simple_idContext) DOCUMENT() antlr.TerminalNode

func (*Simple_idContext) DYNAMIC

func (s *Simple_idContext) DYNAMIC() antlr.TerminalNode

func (*Simple_idContext) EMERGENCY

func (s *Simple_idContext) EMERGENCY() antlr.TerminalNode

func (*Simple_idContext) EMPTY

func (s *Simple_idContext) EMPTY() antlr.TerminalNode

func (*Simple_idContext) ENABLE

func (s *Simple_idContext) ENABLE() antlr.TerminalNode

func (*Simple_idContext) ENABLE_BROKER

func (s *Simple_idContext) ENABLE_BROKER() antlr.TerminalNode

func (*Simple_idContext) ENCRYPTED_VALUE

func (s *Simple_idContext) ENCRYPTED_VALUE() antlr.TerminalNode

func (*Simple_idContext) ENCRYPTION

func (s *Simple_idContext) ENCRYPTION() antlr.TerminalNode

func (*Simple_idContext) ENDPOINT_URL

func (s *Simple_idContext) ENDPOINT_URL() antlr.TerminalNode

func (*Simple_idContext) ERROR_BROKER_CONVERSATIONS

func (s *Simple_idContext) ERROR_BROKER_CONVERSATIONS() antlr.TerminalNode

func (*Simple_idContext) EVENTDATA

func (s *Simple_idContext) EVENTDATA() antlr.TerminalNode

func (*Simple_idContext) EXCLUSIVE

func (s *Simple_idContext) EXCLUSIVE() antlr.TerminalNode

func (*Simple_idContext) EXECUTABLE

func (s *Simple_idContext) EXECUTABLE() antlr.TerminalNode

func (*Simple_idContext) EXIST

func (s *Simple_idContext) EXIST() antlr.TerminalNode

func (*Simple_idContext) EXPAND

func (s *Simple_idContext) EXPAND() antlr.TerminalNode

func (*Simple_idContext) EXPIRY_DATE

func (s *Simple_idContext) EXPIRY_DATE() antlr.TerminalNode

func (*Simple_idContext) EXPLICIT

func (s *Simple_idContext) EXPLICIT() antlr.TerminalNode

func (*Simple_idContext) EnterRule

func (s *Simple_idContext) EnterRule(listener antlr.ParseTreeListener)

func (*Simple_idContext) ExitRule

func (s *Simple_idContext) ExitRule(listener antlr.ParseTreeListener)

func (*Simple_idContext) FAILOVER_MODE

func (s *Simple_idContext) FAILOVER_MODE() antlr.TerminalNode

func (*Simple_idContext) FAILURE

func (s *Simple_idContext) FAILURE() antlr.TerminalNode

func (*Simple_idContext) FAILURE_CONDITION_LEVEL

func (s *Simple_idContext) FAILURE_CONDITION_LEVEL() antlr.TerminalNode

func (*Simple_idContext) FAIL_OPERATION

func (s *Simple_idContext) FAIL_OPERATION() antlr.TerminalNode

func (*Simple_idContext) FAST

func (*Simple_idContext) FAST_FORWARD

func (s *Simple_idContext) FAST_FORWARD() antlr.TerminalNode

func (*Simple_idContext) FILEGROUP

func (s *Simple_idContext) FILEGROUP() antlr.TerminalNode

func (*Simple_idContext) FILEGROWTH

func (s *Simple_idContext) FILEGROWTH() antlr.TerminalNode

func (*Simple_idContext) FILENAME

func (s *Simple_idContext) FILENAME() antlr.TerminalNode

func (*Simple_idContext) FILEPATH

func (s *Simple_idContext) FILEPATH() antlr.TerminalNode

func (*Simple_idContext) FILESTREAM

func (s *Simple_idContext) FILESTREAM() antlr.TerminalNode

func (*Simple_idContext) FILLFACTOR

func (s *Simple_idContext) FILLFACTOR() antlr.TerminalNode

func (*Simple_idContext) FILTER

func (s *Simple_idContext) FILTER() antlr.TerminalNode

func (*Simple_idContext) FIRST

func (s *Simple_idContext) FIRST() antlr.TerminalNode

func (*Simple_idContext) FIRST_VALUE

func (s *Simple_idContext) FIRST_VALUE() antlr.TerminalNode

func (*Simple_idContext) FOLLOWING

func (s *Simple_idContext) FOLLOWING() antlr.TerminalNode

func (*Simple_idContext) FORCE

func (s *Simple_idContext) FORCE() antlr.TerminalNode

func (*Simple_idContext) FORCED

func (s *Simple_idContext) FORCED() antlr.TerminalNode

func (*Simple_idContext) FORCESEEK

func (s *Simple_idContext) FORCESEEK() antlr.TerminalNode

func (*Simple_idContext) FORCE_FAILOVER_ALLOW_DATA_LOSS

func (s *Simple_idContext) FORCE_FAILOVER_ALLOW_DATA_LOSS() antlr.TerminalNode

func (*Simple_idContext) FORMAT

func (s *Simple_idContext) FORMAT() antlr.TerminalNode

func (*Simple_idContext) FORWARD_ONLY

func (s *Simple_idContext) FORWARD_ONLY() antlr.TerminalNode

func (*Simple_idContext) FULLSCAN

func (s *Simple_idContext) FULLSCAN() antlr.TerminalNode

func (*Simple_idContext) FULLTEXT

func (s *Simple_idContext) FULLTEXT() antlr.TerminalNode

func (*Simple_idContext) GB

func (*Simple_idContext) GETDATE

func (s *Simple_idContext) GETDATE() antlr.TerminalNode

func (*Simple_idContext) GETUTCDATE

func (s *Simple_idContext) GETUTCDATE() antlr.TerminalNode

func (*Simple_idContext) GLOBAL

func (s *Simple_idContext) GLOBAL() antlr.TerminalNode

func (*Simple_idContext) GO

func (*Simple_idContext) GROUPING

func (s *Simple_idContext) GROUPING() antlr.TerminalNode

func (*Simple_idContext) GROUPING_ID

func (s *Simple_idContext) GROUPING_ID() antlr.TerminalNode

func (*Simple_idContext) GROUP_MAX_REQUESTS

func (s *Simple_idContext) GROUP_MAX_REQUESTS() antlr.TerminalNode

func (*Simple_idContext) GetParser

func (s *Simple_idContext) GetParser() antlr.Parser

func (*Simple_idContext) GetRuleContext

func (s *Simple_idContext) GetRuleContext() antlr.RuleContext

func (*Simple_idContext) HADR

func (*Simple_idContext) HASH

func (*Simple_idContext) HEALTH_CHECK_TIMEOUT

func (s *Simple_idContext) HEALTH_CHECK_TIMEOUT() antlr.TerminalNode

func (*Simple_idContext) HIGH

func (*Simple_idContext) HONOR_BROKER_PRIORITY

func (s *Simple_idContext) HONOR_BROKER_PRIORITY() antlr.TerminalNode

func (*Simple_idContext) HOURS

func (s *Simple_idContext) HOURS() antlr.TerminalNode

func (*Simple_idContext) ID

func (*Simple_idContext) IDENTITY_VALUE

func (s *Simple_idContext) IDENTITY_VALUE() antlr.TerminalNode

func (*Simple_idContext) IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX

func (s *Simple_idContext) IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX() antlr.TerminalNode

func (*Simple_idContext) IMMEDIATE

func (s *Simple_idContext) IMMEDIATE() antlr.TerminalNode

func (*Simple_idContext) IMPERSONATE

func (s *Simple_idContext) IMPERSONATE() antlr.TerminalNode

func (*Simple_idContext) IMPORTANCE

func (s *Simple_idContext) IMPORTANCE() antlr.TerminalNode

func (*Simple_idContext) INCREMENTAL

func (s *Simple_idContext) INCREMENTAL() antlr.TerminalNode

func (*Simple_idContext) INIT

func (*Simple_idContext) INITIATOR

func (s *Simple_idContext) INITIATOR() antlr.TerminalNode

func (*Simple_idContext) INPUT

func (s *Simple_idContext) INPUT() antlr.TerminalNode

func (*Simple_idContext) INSENSITIVE

func (s *Simple_idContext) INSENSITIVE() antlr.TerminalNode

func (*Simple_idContext) INSERTED

func (s *Simple_idContext) INSERTED() antlr.TerminalNode

func (*Simple_idContext) INT

func (*Simple_idContext) IP

func (*Simple_idContext) ISOLATION

func (s *Simple_idContext) ISOLATION() antlr.TerminalNode

func (*Simple_idContext) IsSimple_idContext

func (*Simple_idContext) IsSimple_idContext()

func (*Simple_idContext) KB

func (*Simple_idContext) KEEP

func (*Simple_idContext) KEEPFIXED

func (s *Simple_idContext) KEEPFIXED() antlr.TerminalNode

func (*Simple_idContext) KEY

func (*Simple_idContext) KEYS

func (*Simple_idContext) KEYSET

func (s *Simple_idContext) KEYSET() antlr.TerminalNode

func (*Simple_idContext) KEY_SOURCE

func (s *Simple_idContext) KEY_SOURCE() antlr.TerminalNode

func (*Simple_idContext) LAG

func (*Simple_idContext) LAST

func (*Simple_idContext) LAST_VALUE

func (s *Simple_idContext) LAST_VALUE() antlr.TerminalNode

func (*Simple_idContext) LEAD

func (*Simple_idContext) LEVEL

func (s *Simple_idContext) LEVEL() antlr.TerminalNode

func (*Simple_idContext) LIST

func (*Simple_idContext) LISTENER

func (s *Simple_idContext) LISTENER() antlr.TerminalNode

func (*Simple_idContext) LISTENER_URL

func (s *Simple_idContext) LISTENER_URL() antlr.TerminalNode

func (*Simple_idContext) LOB_COMPACTION

func (s *Simple_idContext) LOB_COMPACTION() antlr.TerminalNode

func (*Simple_idContext) LOCAL

func (s *Simple_idContext) LOCAL() antlr.TerminalNode

func (*Simple_idContext) LOCATION

func (s *Simple_idContext) LOCATION() antlr.TerminalNode

func (*Simple_idContext) LOCK

func (*Simple_idContext) LOCK_ESCALATION

func (s *Simple_idContext) LOCK_ESCALATION() antlr.TerminalNode

func (*Simple_idContext) LOGIN

func (s *Simple_idContext) LOGIN() antlr.TerminalNode

func (*Simple_idContext) LOOP

func (*Simple_idContext) LOW

func (*Simple_idContext) MANUAL

func (s *Simple_idContext) MANUAL() antlr.TerminalNode

func (*Simple_idContext) MARK

func (*Simple_idContext) MASTER

func (s *Simple_idContext) MASTER() antlr.TerminalNode

func (*Simple_idContext) MATERIALIZED

func (s *Simple_idContext) MATERIALIZED() antlr.TerminalNode

func (*Simple_idContext) MAX

func (*Simple_idContext) MAXDOP

func (s *Simple_idContext) MAXDOP() antlr.TerminalNode

func (*Simple_idContext) MAXRECURSION

func (s *Simple_idContext) MAXRECURSION() antlr.TerminalNode

func (*Simple_idContext) MAXSIZE

func (s *Simple_idContext) MAXSIZE() antlr.TerminalNode

func (*Simple_idContext) MAX_CPU_PERCENT

func (s *Simple_idContext) MAX_CPU_PERCENT() antlr.TerminalNode

func (*Simple_idContext) MAX_DOP

func (s *Simple_idContext) MAX_DOP() antlr.TerminalNode

func (*Simple_idContext) MAX_FILES

func (s *Simple_idContext) MAX_FILES() antlr.TerminalNode

func (*Simple_idContext) MAX_IOPS_PER_VOLUME

func (s *Simple_idContext) MAX_IOPS_PER_VOLUME() antlr.TerminalNode

func (*Simple_idContext) MAX_MEMORY

func (s *Simple_idContext) MAX_MEMORY() antlr.TerminalNode

func (*Simple_idContext) MAX_MEMORY_PERCENT

func (s *Simple_idContext) MAX_MEMORY_PERCENT() antlr.TerminalNode

func (*Simple_idContext) MAX_PROCESSES

func (s *Simple_idContext) MAX_PROCESSES() antlr.TerminalNode

func (*Simple_idContext) MAX_QUEUE_READERS

func (s *Simple_idContext) MAX_QUEUE_READERS() antlr.TerminalNode

func (*Simple_idContext) MAX_ROLLOVER_FILES

func (s *Simple_idContext) MAX_ROLLOVER_FILES() antlr.TerminalNode

func (*Simple_idContext) MB

func (*Simple_idContext) MEDIUM

func (s *Simple_idContext) MEDIUM() antlr.TerminalNode

func (*Simple_idContext) MEMORY_OPTIMIZED_DATA

func (s *Simple_idContext) MEMORY_OPTIMIZED_DATA() antlr.TerminalNode

func (*Simple_idContext) MESSAGE

func (s *Simple_idContext) MESSAGE() antlr.TerminalNode

func (*Simple_idContext) MIN

func (*Simple_idContext) MINUTES

func (s *Simple_idContext) MINUTES() antlr.TerminalNode

func (*Simple_idContext) MIN_ACTIVE_ROWVERSION

func (s *Simple_idContext) MIN_ACTIVE_ROWVERSION() antlr.TerminalNode

func (*Simple_idContext) MIN_CPU_PERCENT

func (s *Simple_idContext) MIN_CPU_PERCENT() antlr.TerminalNode

func (*Simple_idContext) MIN_IOPS_PER_VOLUME

func (s *Simple_idContext) MIN_IOPS_PER_VOLUME() antlr.TerminalNode

func (*Simple_idContext) MIN_MEMORY_PERCENT

func (s *Simple_idContext) MIN_MEMORY_PERCENT() antlr.TerminalNode

func (*Simple_idContext) MIRROR_ADDRESS

func (s *Simple_idContext) MIRROR_ADDRESS() antlr.TerminalNode

func (*Simple_idContext) MIXED_PAGE_ALLOCATION

func (s *Simple_idContext) MIXED_PAGE_ALLOCATION() antlr.TerminalNode

func (*Simple_idContext) MODE

func (*Simple_idContext) MODIFY

func (s *Simple_idContext) MODIFY() antlr.TerminalNode

func (*Simple_idContext) MOVE

func (*Simple_idContext) MULTI_USER

func (s *Simple_idContext) MULTI_USER() antlr.TerminalNode

func (*Simple_idContext) NAME

func (*Simple_idContext) NESTED_TRIGGERS

func (s *Simple_idContext) NESTED_TRIGGERS() antlr.TerminalNode

func (*Simple_idContext) NEW_ACCOUNT

func (s *Simple_idContext) NEW_ACCOUNT() antlr.TerminalNode

func (*Simple_idContext) NEW_BROKER

func (s *Simple_idContext) NEW_BROKER() antlr.TerminalNode

func (*Simple_idContext) NEW_PASSWORD

func (s *Simple_idContext) NEW_PASSWORD() antlr.TerminalNode

func (*Simple_idContext) NEXT

func (*Simple_idContext) NO

func (*Simple_idContext) NOCOUNT

func (s *Simple_idContext) NOCOUNT() antlr.TerminalNode

func (*Simple_idContext) NODES

func (s *Simple_idContext) NODES() antlr.TerminalNode

func (*Simple_idContext) NOEXPAND

func (s *Simple_idContext) NOEXPAND() antlr.TerminalNode

func (*Simple_idContext) NON_TRANSACTED_ACCESS

func (s *Simple_idContext) NON_TRANSACTED_ACCESS() antlr.TerminalNode

func (*Simple_idContext) NORECOMPUTE

func (s *Simple_idContext) NORECOMPUTE() antlr.TerminalNode

func (*Simple_idContext) NORECOVERY

func (s *Simple_idContext) NORECOVERY() antlr.TerminalNode

func (*Simple_idContext) NOWAIT

func (s *Simple_idContext) NOWAIT() antlr.TerminalNode

func (*Simple_idContext) NO_TRUNCATE

func (s *Simple_idContext) NO_TRUNCATE() antlr.TerminalNode

func (*Simple_idContext) NO_WAIT

func (s *Simple_idContext) NO_WAIT() antlr.TerminalNode

func (*Simple_idContext) NTILE

func (s *Simple_idContext) NTILE() antlr.TerminalNode

func (*Simple_idContext) NUMANODE

func (s *Simple_idContext) NUMANODE() antlr.TerminalNode

func (*Simple_idContext) NUMBER

func (s *Simple_idContext) NUMBER() antlr.TerminalNode

func (*Simple_idContext) NUMERIC_ROUNDABORT

func (s *Simple_idContext) NUMERIC_ROUNDABORT() antlr.TerminalNode

func (*Simple_idContext) OBJECT

func (s *Simple_idContext) OBJECT() antlr.TerminalNode

func (*Simple_idContext) OFFLINE

func (s *Simple_idContext) OFFLINE() antlr.TerminalNode

func (*Simple_idContext) OFFSET

func (s *Simple_idContext) OFFSET() antlr.TerminalNode

func (*Simple_idContext) OFFSETS

func (s *Simple_idContext) OFFSETS() antlr.TerminalNode

func (*Simple_idContext) OLD_ACCOUNT

func (s *Simple_idContext) OLD_ACCOUNT() antlr.TerminalNode

func (*Simple_idContext) ONLINE

func (s *Simple_idContext) ONLINE() antlr.TerminalNode

func (*Simple_idContext) ONLY

func (*Simple_idContext) OPEN_EXISTING

func (s *Simple_idContext) OPEN_EXISTING() antlr.TerminalNode

func (*Simple_idContext) OPTIMISTIC

func (s *Simple_idContext) OPTIMISTIC() antlr.TerminalNode

func (*Simple_idContext) OPTIMIZE

func (s *Simple_idContext) OPTIMIZE() antlr.TerminalNode

func (*Simple_idContext) OUT

func (*Simple_idContext) OUTPUT

func (s *Simple_idContext) OUTPUT() antlr.TerminalNode

func (*Simple_idContext) OWNER

func (s *Simple_idContext) OWNER() antlr.TerminalNode

func (*Simple_idContext) PAGE

func (*Simple_idContext) PAGE_VERIFY

func (s *Simple_idContext) PAGE_VERIFY() antlr.TerminalNode

func (*Simple_idContext) PARAMETERIZATION

func (s *Simple_idContext) PARAMETERIZATION() antlr.TerminalNode

func (*Simple_idContext) PARTITION

func (s *Simple_idContext) PARTITION() antlr.TerminalNode

func (*Simple_idContext) PARTITIONS

func (s *Simple_idContext) PARTITIONS() antlr.TerminalNode

func (*Simple_idContext) PARTNER

func (s *Simple_idContext) PARTNER() antlr.TerminalNode

func (*Simple_idContext) PATH

func (*Simple_idContext) POISON_MESSAGE_HANDLING

func (s *Simple_idContext) POISON_MESSAGE_HANDLING() antlr.TerminalNode

func (*Simple_idContext) POOL

func (*Simple_idContext) PORT

func (*Simple_idContext) PRECEDING

func (s *Simple_idContext) PRECEDING() antlr.TerminalNode

func (*Simple_idContext) PRIMARY_ROLE

func (s *Simple_idContext) PRIMARY_ROLE() antlr.TerminalNode

func (*Simple_idContext) PRIOR

func (s *Simple_idContext) PRIOR() antlr.TerminalNode

func (*Simple_idContext) PRIORITY

func (s *Simple_idContext) PRIORITY() antlr.TerminalNode

func (*Simple_idContext) PRIORITY_LEVEL

func (s *Simple_idContext) PRIORITY_LEVEL() antlr.TerminalNode

func (*Simple_idContext) PRIVATE

func (s *Simple_idContext) PRIVATE() antlr.TerminalNode

func (*Simple_idContext) PRIVATE_KEY

func (s *Simple_idContext) PRIVATE_KEY() antlr.TerminalNode

func (*Simple_idContext) PRIVILEGES

func (s *Simple_idContext) PRIVILEGES() antlr.TerminalNode

func (*Simple_idContext) PROCEDURE_NAME

func (s *Simple_idContext) PROCEDURE_NAME() antlr.TerminalNode

func (*Simple_idContext) PROPERTY

func (s *Simple_idContext) PROPERTY() antlr.TerminalNode

func (*Simple_idContext) PROVIDER

func (s *Simple_idContext) PROVIDER() antlr.TerminalNode

func (*Simple_idContext) PROVIDER_KEY_NAME

func (s *Simple_idContext) PROVIDER_KEY_NAME() antlr.TerminalNode

func (*Simple_idContext) PUBLIC

func (s *Simple_idContext) PUBLIC() antlr.TerminalNode

func (*Simple_idContext) QUERY

func (s *Simple_idContext) QUERY() antlr.TerminalNode

func (*Simple_idContext) QUEUE

func (s *Simple_idContext) QUEUE() antlr.TerminalNode

func (*Simple_idContext) QUEUE_DELAY

func (s *Simple_idContext) QUEUE_DELAY() antlr.TerminalNode

func (*Simple_idContext) QUOTED_IDENTIFIER

func (s *Simple_idContext) QUOTED_IDENTIFIER() antlr.TerminalNode

func (*Simple_idContext) R

func (*Simple_idContext) RANGE

func (s *Simple_idContext) RANGE() antlr.TerminalNode

func (*Simple_idContext) RANK

func (*Simple_idContext) RAW

func (*Simple_idContext) RC2

func (*Simple_idContext) RC4

func (*Simple_idContext) RC4_128

func (s *Simple_idContext) RC4_128() antlr.TerminalNode

func (*Simple_idContext) READONLY

func (s *Simple_idContext) READONLY() antlr.TerminalNode

func (*Simple_idContext) READ_COMMITTED_SNAPSHOT

func (s *Simple_idContext) READ_COMMITTED_SNAPSHOT() antlr.TerminalNode

func (*Simple_idContext) READ_ONLY

func (s *Simple_idContext) READ_ONLY() antlr.TerminalNode

func (*Simple_idContext) READ_ONLY_ROUTING_LIST

func (s *Simple_idContext) READ_ONLY_ROUTING_LIST() antlr.TerminalNode

func (*Simple_idContext) READ_WRITE

func (s *Simple_idContext) READ_WRITE() antlr.TerminalNode

func (*Simple_idContext) REBUILD

func (s *Simple_idContext) REBUILD() antlr.TerminalNode

func (*Simple_idContext) RECEIVE

func (s *Simple_idContext) RECEIVE() antlr.TerminalNode

func (*Simple_idContext) RECOMPILE

func (s *Simple_idContext) RECOMPILE() antlr.TerminalNode

func (*Simple_idContext) RECOVERY

func (s *Simple_idContext) RECOVERY() antlr.TerminalNode

func (*Simple_idContext) RECURSIVE_TRIGGERS

func (s *Simple_idContext) RECURSIVE_TRIGGERS() antlr.TerminalNode

func (*Simple_idContext) RELATIVE

func (s *Simple_idContext) RELATIVE() antlr.TerminalNode

func (*Simple_idContext) REMOTE

func (s *Simple_idContext) REMOTE() antlr.TerminalNode

func (*Simple_idContext) REMOTE_SERVICE_NAME

func (s *Simple_idContext) REMOTE_SERVICE_NAME() antlr.TerminalNode

func (*Simple_idContext) REMOVE

func (s *Simple_idContext) REMOVE() antlr.TerminalNode

func (*Simple_idContext) REORGANIZE

func (s *Simple_idContext) REORGANIZE() antlr.TerminalNode

func (*Simple_idContext) REPEATABLE

func (s *Simple_idContext) REPEATABLE() antlr.TerminalNode

func (*Simple_idContext) REPLICA

func (s *Simple_idContext) REPLICA() antlr.TerminalNode

func (*Simple_idContext) REQUEST_MAX_CPU_TIME_SEC

func (s *Simple_idContext) REQUEST_MAX_CPU_TIME_SEC() antlr.TerminalNode

func (*Simple_idContext) REQUEST_MAX_MEMORY_GRANT_PERCENT

func (s *Simple_idContext) REQUEST_MAX_MEMORY_GRANT_PERCENT() antlr.TerminalNode

func (*Simple_idContext) REQUEST_MEMORY_GRANT_TIMEOUT_SEC

func (s *Simple_idContext) REQUEST_MEMORY_GRANT_TIMEOUT_SEC() antlr.TerminalNode

func (*Simple_idContext) REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT

func (s *Simple_idContext) REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT() antlr.TerminalNode

func (*Simple_idContext) RESERVE_DISK_SPACE

func (s *Simple_idContext) RESERVE_DISK_SPACE() antlr.TerminalNode

func (*Simple_idContext) RESOURCE

func (s *Simple_idContext) RESOURCE() antlr.TerminalNode

func (*Simple_idContext) RESOURCE_MANAGER_LOCATION

func (s *Simple_idContext) RESOURCE_MANAGER_LOCATION() antlr.TerminalNode

func (*Simple_idContext) RESTRICTED_USER

func (s *Simple_idContext) RESTRICTED_USER() antlr.TerminalNode

func (*Simple_idContext) RETENTION

func (s *Simple_idContext) RETENTION() antlr.TerminalNode

func (*Simple_idContext) RETURN

func (s *Simple_idContext) RETURN() antlr.TerminalNode

func (*Simple_idContext) RETURNS

func (s *Simple_idContext) RETURNS() antlr.TerminalNode

func (*Simple_idContext) ROBUST

func (s *Simple_idContext) ROBUST() antlr.TerminalNode

func (*Simple_idContext) ROOT

func (*Simple_idContext) ROUTE

func (s *Simple_idContext) ROUTE() antlr.TerminalNode

func (*Simple_idContext) ROW

func (*Simple_idContext) ROWCOUNT

func (s *Simple_idContext) ROWCOUNT() antlr.TerminalNode

func (*Simple_idContext) ROWGUID

func (s *Simple_idContext) ROWGUID() antlr.TerminalNode

func (*Simple_idContext) ROWS

func (*Simple_idContext) ROW_NUMBER

func (s *Simple_idContext) ROW_NUMBER() antlr.TerminalNode

func (*Simple_idContext) SAFETY

func (s *Simple_idContext) SAFETY() antlr.TerminalNode

func (*Simple_idContext) SAMPLE

func (s *Simple_idContext) SAMPLE() antlr.TerminalNode

func (*Simple_idContext) SCHEMABINDING

func (s *Simple_idContext) SCHEMABINDING() antlr.TerminalNode

func (*Simple_idContext) SCOPED

func (s *Simple_idContext) SCOPED() antlr.TerminalNode

func (*Simple_idContext) SCROLL

func (s *Simple_idContext) SCROLL() antlr.TerminalNode

func (*Simple_idContext) SCROLL_LOCKS

func (s *Simple_idContext) SCROLL_LOCKS() antlr.TerminalNode

func (*Simple_idContext) SEARCH

func (s *Simple_idContext) SEARCH() antlr.TerminalNode

func (*Simple_idContext) SECONDARY

func (s *Simple_idContext) SECONDARY() antlr.TerminalNode

func (*Simple_idContext) SECONDARY_ONLY

func (s *Simple_idContext) SECONDARY_ONLY() antlr.TerminalNode

func (*Simple_idContext) SECONDARY_ROLE

func (s *Simple_idContext) SECONDARY_ROLE() antlr.TerminalNode

func (*Simple_idContext) SECONDS

func (s *Simple_idContext) SECONDS() antlr.TerminalNode

func (*Simple_idContext) SECRET

func (s *Simple_idContext) SECRET() antlr.TerminalNode

func (*Simple_idContext) SECURITY_LOG

func (s *Simple_idContext) SECURITY_LOG() antlr.TerminalNode

func (*Simple_idContext) SEEDING_MODE

func (s *Simple_idContext) SEEDING_MODE() antlr.TerminalNode

func (*Simple_idContext) SELF

func (*Simple_idContext) SEMI_SENSITIVE

func (s *Simple_idContext) SEMI_SENSITIVE() antlr.TerminalNode

func (*Simple_idContext) SEND

func (*Simple_idContext) SENT

func (*Simple_idContext) SERIALIZABLE

func (s *Simple_idContext) SERIALIZABLE() antlr.TerminalNode

func (*Simple_idContext) SERVER

func (s *Simple_idContext) SERVER() antlr.TerminalNode

func (*Simple_idContext) SESSION_TIMEOUT

func (s *Simple_idContext) SESSION_TIMEOUT() antlr.TerminalNode

func (*Simple_idContext) SETERROR

func (s *Simple_idContext) SETERROR() antlr.TerminalNode

func (*Simple_idContext) SHARE

func (s *Simple_idContext) SHARE() antlr.TerminalNode

func (*Simple_idContext) SHOWPLAN

func (s *Simple_idContext) SHOWPLAN() antlr.TerminalNode

func (*Simple_idContext) SID

func (*Simple_idContext) SIGNATURE

func (s *Simple_idContext) SIGNATURE() antlr.TerminalNode

func (*Simple_idContext) SIMPLE

func (s *Simple_idContext) SIMPLE() antlr.TerminalNode

func (*Simple_idContext) SINGLE_USER

func (s *Simple_idContext) SINGLE_USER() antlr.TerminalNode

func (*Simple_idContext) SIZE

func (*Simple_idContext) SMALLINT

func (s *Simple_idContext) SMALLINT() antlr.TerminalNode

func (*Simple_idContext) SNAPSHOT

func (s *Simple_idContext) SNAPSHOT() antlr.TerminalNode

func (*Simple_idContext) SOURCE

func (s *Simple_idContext) SOURCE() antlr.TerminalNode

func (*Simple_idContext) SPATIAL_WINDOW_MAX_CELLS

func (s *Simple_idContext) SPATIAL_WINDOW_MAX_CELLS() antlr.TerminalNode

func (*Simple_idContext) STANDBY

func (s *Simple_idContext) STANDBY() antlr.TerminalNode

func (*Simple_idContext) START

func (s *Simple_idContext) START() antlr.TerminalNode

func (*Simple_idContext) START_DATE

func (s *Simple_idContext) START_DATE() antlr.TerminalNode

func (*Simple_idContext) STATE

func (s *Simple_idContext) STATE() antlr.TerminalNode

func (*Simple_idContext) STATIC

func (s *Simple_idContext) STATIC() antlr.TerminalNode

func (*Simple_idContext) STATS_STREAM

func (s *Simple_idContext) STATS_STREAM() antlr.TerminalNode

func (*Simple_idContext) STATUS

func (s *Simple_idContext) STATUS() antlr.TerminalNode

func (*Simple_idContext) STDEV

func (s *Simple_idContext) STDEV() antlr.TerminalNode

func (*Simple_idContext) STDEVP

func (s *Simple_idContext) STDEVP() antlr.TerminalNode

func (*Simple_idContext) STOPLIST

func (s *Simple_idContext) STOPLIST() antlr.TerminalNode

func (*Simple_idContext) STUFF

func (s *Simple_idContext) STUFF() antlr.TerminalNode

func (*Simple_idContext) SUBJECT

func (s *Simple_idContext) SUBJECT() antlr.TerminalNode

func (*Simple_idContext) SUM

func (*Simple_idContext) SUSPEND

func (s *Simple_idContext) SUSPEND() antlr.TerminalNode

func (*Simple_idContext) SYMMETRIC

func (s *Simple_idContext) SYMMETRIC() antlr.TerminalNode

func (*Simple_idContext) SYNCHRONOUS_COMMIT

func (s *Simple_idContext) SYNCHRONOUS_COMMIT() antlr.TerminalNode

func (*Simple_idContext) SYNONYM

func (s *Simple_idContext) SYNONYM() antlr.TerminalNode

func (*Simple_idContext) TAKE

func (*Simple_idContext) TARGET

func (s *Simple_idContext) TARGET() antlr.TerminalNode

func (*Simple_idContext) TARGET_RECOVERY_TIME

func (s *Simple_idContext) TARGET_RECOVERY_TIME() antlr.TerminalNode

func (*Simple_idContext) TB

func (*Simple_idContext) TEXTIMAGE_ON

func (s *Simple_idContext) TEXTIMAGE_ON() antlr.TerminalNode

func (*Simple_idContext) THROW

func (s *Simple_idContext) THROW() antlr.TerminalNode

func (*Simple_idContext) TIES

func (*Simple_idContext) TIME

func (*Simple_idContext) TIMEOUT

func (s *Simple_idContext) TIMEOUT() antlr.TerminalNode

func (*Simple_idContext) TIMER

func (s *Simple_idContext) TIMER() antlr.TerminalNode

func (*Simple_idContext) TINYINT

func (s *Simple_idContext) TINYINT() antlr.TerminalNode

func (*Simple_idContext) TORN_PAGE_DETECTION

func (s *Simple_idContext) TORN_PAGE_DETECTION() antlr.TerminalNode

func (*Simple_idContext) TRANSFORM_NOISE_WORDS

func (s *Simple_idContext) TRANSFORM_NOISE_WORDS() antlr.TerminalNode

func (*Simple_idContext) TRIPLE_DES

func (s *Simple_idContext) TRIPLE_DES() antlr.TerminalNode

func (*Simple_idContext) TRIPLE_DES_3KEY

func (s *Simple_idContext) TRIPLE_DES_3KEY() antlr.TerminalNode

func (*Simple_idContext) TRUSTWORTHY

func (s *Simple_idContext) TRUSTWORTHY() antlr.TerminalNode

func (*Simple_idContext) TRY

func (*Simple_idContext) TSQL

func (*Simple_idContext) TWO_DIGIT_YEAR_CUTOFF

func (s *Simple_idContext) TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode

func (*Simple_idContext) TYPE

func (*Simple_idContext) TYPE_WARNING

func (s *Simple_idContext) TYPE_WARNING() antlr.TerminalNode

func (*Simple_idContext) ToStringTree

func (s *Simple_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Simple_idContext) UNBOUNDED

func (s *Simple_idContext) UNBOUNDED() antlr.TerminalNode

func (*Simple_idContext) UNCOMMITTED

func (s *Simple_idContext) UNCOMMITTED() antlr.TerminalNode

func (*Simple_idContext) UNKNOWN

func (s *Simple_idContext) UNKNOWN() antlr.TerminalNode

func (*Simple_idContext) UNLIMITED

func (s *Simple_idContext) UNLIMITED() antlr.TerminalNode

func (*Simple_idContext) USING

func (s *Simple_idContext) USING() antlr.TerminalNode

func (*Simple_idContext) VALIDATION

func (s *Simple_idContext) VALIDATION() antlr.TerminalNode

func (*Simple_idContext) VALID_XML

func (s *Simple_idContext) VALID_XML() antlr.TerminalNode

func (*Simple_idContext) VALUE

func (s *Simple_idContext) VALUE() antlr.TerminalNode

func (*Simple_idContext) VAR

func (*Simple_idContext) VARP

func (*Simple_idContext) VIEWS

func (s *Simple_idContext) VIEWS() antlr.TerminalNode

func (*Simple_idContext) VIEW_METADATA

func (s *Simple_idContext) VIEW_METADATA() antlr.TerminalNode

func (*Simple_idContext) WAIT

func (*Simple_idContext) WELL_FORMED_XML

func (s *Simple_idContext) WELL_FORMED_XML() antlr.TerminalNode

func (*Simple_idContext) WORK

func (*Simple_idContext) WORKLOAD

func (s *Simple_idContext) WORKLOAD() antlr.TerminalNode

func (*Simple_idContext) XML

func (*Simple_idContext) XMLNAMESPACES

func (s *Simple_idContext) XMLNAMESPACES() antlr.TerminalNode

type Simple_nameContext

type Simple_nameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySimple_nameContext

func NewEmptySimple_nameContext() *Simple_nameContext

func NewSimple_nameContext

func NewSimple_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_nameContext

func (*Simple_nameContext) AllId

func (s *Simple_nameContext) AllId() []IIdContext

func (*Simple_nameContext) DOT

func (*Simple_nameContext) EnterRule

func (s *Simple_nameContext) EnterRule(listener antlr.ParseTreeListener)

func (*Simple_nameContext) ExitRule

func (s *Simple_nameContext) ExitRule(listener antlr.ParseTreeListener)

func (*Simple_nameContext) GetName

func (s *Simple_nameContext) GetName() IIdContext

func (*Simple_nameContext) GetParser

func (s *Simple_nameContext) GetParser() antlr.Parser

func (*Simple_nameContext) GetRuleContext

func (s *Simple_nameContext) GetRuleContext() antlr.RuleContext

func (*Simple_nameContext) GetSchema

func (s *Simple_nameContext) GetSchema() IIdContext

func (*Simple_nameContext) Id

func (*Simple_nameContext) IsSimple_nameContext

func (*Simple_nameContext) IsSimple_nameContext()

func (*Simple_nameContext) SetName

func (s *Simple_nameContext) SetName(v IIdContext)

func (*Simple_nameContext) SetSchema

func (s *Simple_nameContext) SetSchema(v IIdContext)

func (*Simple_nameContext) ToStringTree

func (s *Simple_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Snapshot_optionContext

type Snapshot_optionContext struct {
	*antlr.BaseParserRuleContext

	MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT antlr.Token
	// contains filtered or unexported fields
}

func NewEmptySnapshot_optionContext

func NewEmptySnapshot_optionContext() *Snapshot_optionContext

func NewSnapshot_optionContext

func NewSnapshot_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Snapshot_optionContext

func (*Snapshot_optionContext) ALLOW_SNAPSHOT_ISOLATION

func (s *Snapshot_optionContext) ALLOW_SNAPSHOT_ISOLATION() antlr.TerminalNode

func (*Snapshot_optionContext) EnterRule

func (s *Snapshot_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Snapshot_optionContext) ExitRule

func (s *Snapshot_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Snapshot_optionContext) GetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT

func (s *Snapshot_optionContext) GetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT() antlr.Token

func (*Snapshot_optionContext) GetParser

func (s *Snapshot_optionContext) GetParser() antlr.Parser

func (*Snapshot_optionContext) GetRuleContext

func (s *Snapshot_optionContext) GetRuleContext() antlr.RuleContext

func (*Snapshot_optionContext) IsSnapshot_optionContext

func (*Snapshot_optionContext) IsSnapshot_optionContext()

func (*Snapshot_optionContext) OFF

func (*Snapshot_optionContext) ON

func (*Snapshot_optionContext) On_off

func (*Snapshot_optionContext) READ_COMMITTED_SNAPSHOT

func (s *Snapshot_optionContext) READ_COMMITTED_SNAPSHOT() antlr.TerminalNode

func (*Snapshot_optionContext) SetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT

func (s *Snapshot_optionContext) SetMEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT(v antlr.Token)

func (*Snapshot_optionContext) ToStringTree

func (s *Snapshot_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Sql_clauseContext

type Sql_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySql_clauseContext

func NewEmptySql_clauseContext() *Sql_clauseContext

func NewSql_clauseContext

func NewSql_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_clauseContext

func (*Sql_clauseContext) Another_statement

func (s *Sql_clauseContext) Another_statement() IAnother_statementContext

func (*Sql_clauseContext) Backup_statement

func (s *Sql_clauseContext) Backup_statement() IBackup_statementContext

func (*Sql_clauseContext) Cfl_statement

func (s *Sql_clauseContext) Cfl_statement() ICfl_statementContext

func (*Sql_clauseContext) Dbcc_clause

func (s *Sql_clauseContext) Dbcc_clause() IDbcc_clauseContext

func (*Sql_clauseContext) Ddl_clause

func (s *Sql_clauseContext) Ddl_clause() IDdl_clauseContext

func (*Sql_clauseContext) Dml_clause

func (s *Sql_clauseContext) Dml_clause() IDml_clauseContext

func (*Sql_clauseContext) Empty_statement

func (s *Sql_clauseContext) Empty_statement() IEmpty_statementContext

func (*Sql_clauseContext) EnterRule

func (s *Sql_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Sql_clauseContext) ExitRule

func (s *Sql_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Sql_clauseContext) GetParser

func (s *Sql_clauseContext) GetParser() antlr.Parser

func (*Sql_clauseContext) GetRuleContext

func (s *Sql_clauseContext) GetRuleContext() antlr.RuleContext

func (*Sql_clauseContext) IsSql_clauseContext

func (*Sql_clauseContext) IsSql_clauseContext()

func (*Sql_clauseContext) ToStringTree

func (s *Sql_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Sql_clausesContext

type Sql_clausesContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySql_clausesContext

func NewEmptySql_clausesContext() *Sql_clausesContext

func NewSql_clausesContext

func NewSql_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_clausesContext

func (*Sql_clausesContext) AllSEMI

func (s *Sql_clausesContext) AllSEMI() []antlr.TerminalNode

func (*Sql_clausesContext) AllSql_clause

func (s *Sql_clausesContext) AllSql_clause() []ISql_clauseContext

func (*Sql_clausesContext) EnterRule

func (s *Sql_clausesContext) EnterRule(listener antlr.ParseTreeListener)

func (*Sql_clausesContext) ExitRule

func (s *Sql_clausesContext) ExitRule(listener antlr.ParseTreeListener)

func (*Sql_clausesContext) GetParser

func (s *Sql_clausesContext) GetParser() antlr.Parser

func (*Sql_clausesContext) GetRuleContext

func (s *Sql_clausesContext) GetRuleContext() antlr.RuleContext

func (*Sql_clausesContext) IsSql_clausesContext

func (*Sql_clausesContext) IsSql_clausesContext()

func (*Sql_clausesContext) SEMI

func (*Sql_clausesContext) Sql_clause

func (s *Sql_clausesContext) Sql_clause(i int) ISql_clauseContext

func (*Sql_clausesContext) ToStringTree

func (s *Sql_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Sql_optionContext

type Sql_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySql_optionContext

func NewEmptySql_optionContext() *Sql_optionContext

func NewSql_optionContext

func NewSql_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_optionContext

func (*Sql_optionContext) ANSI_NULLS

func (s *Sql_optionContext) ANSI_NULLS() antlr.TerminalNode

func (*Sql_optionContext) ANSI_NULL_DEFAULT

func (s *Sql_optionContext) ANSI_NULL_DEFAULT() antlr.TerminalNode

func (*Sql_optionContext) ANSI_PADDING

func (s *Sql_optionContext) ANSI_PADDING() antlr.TerminalNode

func (*Sql_optionContext) ANSI_WARNINGS

func (s *Sql_optionContext) ANSI_WARNINGS() antlr.TerminalNode

func (*Sql_optionContext) ARITHABORT

func (s *Sql_optionContext) ARITHABORT() antlr.TerminalNode

func (*Sql_optionContext) COMPATIBILITY_LEVEL

func (s *Sql_optionContext) COMPATIBILITY_LEVEL() antlr.TerminalNode

func (*Sql_optionContext) CONCAT_NULL_YIELDS_NULL

func (s *Sql_optionContext) CONCAT_NULL_YIELDS_NULL() antlr.TerminalNode

func (*Sql_optionContext) DECIMAL

func (s *Sql_optionContext) DECIMAL() antlr.TerminalNode

func (*Sql_optionContext) EQUAL

func (*Sql_optionContext) EnterRule

func (s *Sql_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Sql_optionContext) ExitRule

func (s *Sql_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Sql_optionContext) GetParser

func (s *Sql_optionContext) GetParser() antlr.Parser

func (*Sql_optionContext) GetRuleContext

func (s *Sql_optionContext) GetRuleContext() antlr.RuleContext

func (*Sql_optionContext) IsSql_optionContext

func (*Sql_optionContext) IsSql_optionContext()

func (*Sql_optionContext) NUMERIC_ROUNDABORT

func (s *Sql_optionContext) NUMERIC_ROUNDABORT() antlr.TerminalNode

func (*Sql_optionContext) On_off

func (s *Sql_optionContext) On_off() IOn_offContext

func (*Sql_optionContext) QUOTED_IDENTIFIER

func (s *Sql_optionContext) QUOTED_IDENTIFIER() antlr.TerminalNode

func (*Sql_optionContext) RECURSIVE_TRIGGERS

func (s *Sql_optionContext) RECURSIVE_TRIGGERS() antlr.TerminalNode

func (*Sql_optionContext) ToStringTree

func (s *Sql_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Sql_unionContext

type Sql_unionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySql_unionContext

func NewEmptySql_unionContext() *Sql_unionContext

func NewSql_unionContext

func NewSql_unionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_unionContext

func (*Sql_unionContext) ALL

func (*Sql_unionContext) EXCEPT

func (s *Sql_unionContext) EXCEPT() antlr.TerminalNode

func (*Sql_unionContext) EnterRule

func (s *Sql_unionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Sql_unionContext) ExitRule

func (s *Sql_unionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Sql_unionContext) GetParser

func (s *Sql_unionContext) GetParser() antlr.Parser

func (*Sql_unionContext) GetRuleContext

func (s *Sql_unionContext) GetRuleContext() antlr.RuleContext

func (*Sql_unionContext) INTERSECT

func (s *Sql_unionContext) INTERSECT() antlr.TerminalNode

func (*Sql_unionContext) IsSql_unionContext

func (*Sql_unionContext) IsSql_unionContext()

func (*Sql_unionContext) LR_BRACKET

func (s *Sql_unionContext) LR_BRACKET() antlr.TerminalNode

func (*Sql_unionContext) Query_expression

func (s *Sql_unionContext) Query_expression() IQuery_expressionContext

func (*Sql_unionContext) Query_specification

func (s *Sql_unionContext) Query_specification() IQuery_specificationContext

func (*Sql_unionContext) RR_BRACKET

func (s *Sql_unionContext) RR_BRACKET() antlr.TerminalNode

func (*Sql_unionContext) ToStringTree

func (s *Sql_unionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Sql_unionContext) UNION

func (s *Sql_unionContext) UNION() antlr.TerminalNode

type SubqueryContext

type SubqueryContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySubqueryContext

func NewEmptySubqueryContext() *SubqueryContext

func NewSubqueryContext

func NewSubqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubqueryContext

func (*SubqueryContext) EnterRule

func (s *SubqueryContext) EnterRule(listener antlr.ParseTreeListener)

func (*SubqueryContext) ExitRule

func (s *SubqueryContext) ExitRule(listener antlr.ParseTreeListener)

func (*SubqueryContext) GetParser

func (s *SubqueryContext) GetParser() antlr.Parser

func (*SubqueryContext) GetRuleContext

func (s *SubqueryContext) GetRuleContext() antlr.RuleContext

func (*SubqueryContext) IsSubqueryContext

func (*SubqueryContext) IsSubqueryContext()

func (*SubqueryContext) Select_statement

func (s *SubqueryContext) Select_statement() ISelect_statementContext

func (*SubqueryContext) ToStringTree

func (s *SubqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Switch_search_condition_sectionContext

type Switch_search_condition_sectionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySwitch_search_condition_sectionContext

func NewEmptySwitch_search_condition_sectionContext() *Switch_search_condition_sectionContext

func NewSwitch_search_condition_sectionContext

func NewSwitch_search_condition_sectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Switch_search_condition_sectionContext

func (*Switch_search_condition_sectionContext) EnterRule

func (*Switch_search_condition_sectionContext) ExitRule

func (*Switch_search_condition_sectionContext) Expression

func (*Switch_search_condition_sectionContext) GetParser

func (*Switch_search_condition_sectionContext) GetRuleContext

func (*Switch_search_condition_sectionContext) IsSwitch_search_condition_sectionContext

func (*Switch_search_condition_sectionContext) IsSwitch_search_condition_sectionContext()

func (*Switch_search_condition_sectionContext) Search_condition

func (*Switch_search_condition_sectionContext) THEN

func (*Switch_search_condition_sectionContext) ToStringTree

func (s *Switch_search_condition_sectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Switch_search_condition_sectionContext) WHEN

type Switch_sectionContext

type Switch_sectionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySwitch_sectionContext

func NewEmptySwitch_sectionContext() *Switch_sectionContext

func NewSwitch_sectionContext

func NewSwitch_sectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Switch_sectionContext

func (*Switch_sectionContext) AllExpression

func (s *Switch_sectionContext) AllExpression() []IExpressionContext

func (*Switch_sectionContext) EnterRule

func (s *Switch_sectionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Switch_sectionContext) ExitRule

func (s *Switch_sectionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Switch_sectionContext) Expression

func (s *Switch_sectionContext) Expression(i int) IExpressionContext

func (*Switch_sectionContext) GetParser

func (s *Switch_sectionContext) GetParser() antlr.Parser

func (*Switch_sectionContext) GetRuleContext

func (s *Switch_sectionContext) GetRuleContext() antlr.RuleContext

func (*Switch_sectionContext) IsSwitch_sectionContext

func (*Switch_sectionContext) IsSwitch_sectionContext()

func (*Switch_sectionContext) THEN

func (*Switch_sectionContext) ToStringTree

func (s *Switch_sectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Switch_sectionContext) WHEN

type TSqlLexer

type TSqlLexer struct {
	*antlr.BaseLexer
	// contains filtered or unexported fields
}

func NewTSqlLexer

func NewTSqlLexer(input antlr.CharStream) *TSqlLexer

type TSqlParser

type TSqlParser struct {
	*antlr.BaseParser
}

func NewTSqlParser

func NewTSqlParser(input antlr.TokenStream) *TSqlParser

func (*TSqlParser) Aggregate_windowed_function

func (p *TSqlParser) Aggregate_windowed_function() (localctx IAggregate_windowed_functionContext)

func (*TSqlParser) Algorithm

func (p *TSqlParser) Algorithm() (localctx IAlgorithmContext)

func (*TSqlParser) All_distinct_expression

func (p *TSqlParser) All_distinct_expression() (localctx IAll_distinct_expressionContext)

func (*TSqlParser) Alter_application_role

func (p *TSqlParser) Alter_application_role() (localctx IAlter_application_roleContext)

func (*TSqlParser) Alter_assembly

func (p *TSqlParser) Alter_assembly() (localctx IAlter_assemblyContext)

func (*TSqlParser) Alter_assembly_add_clause

func (p *TSqlParser) Alter_assembly_add_clause() (localctx IAlter_assembly_add_clauseContext)

func (*TSqlParser) Alter_assembly_as

func (p *TSqlParser) Alter_assembly_as() (localctx IAlter_assembly_asContext)

func (*TSqlParser) Alter_assembly_clause

func (p *TSqlParser) Alter_assembly_clause() (localctx IAlter_assembly_clauseContext)

func (*TSqlParser) Alter_assembly_client_file_clause

func (p *TSqlParser) Alter_assembly_client_file_clause() (localctx IAlter_assembly_client_file_clauseContext)

func (*TSqlParser) Alter_assembly_drop

func (p *TSqlParser) Alter_assembly_drop() (localctx IAlter_assembly_dropContext)

func (*TSqlParser) Alter_assembly_drop_clause

func (p *TSqlParser) Alter_assembly_drop_clause() (localctx IAlter_assembly_drop_clauseContext)

func (*TSqlParser) Alter_assembly_drop_multiple_files

func (p *TSqlParser) Alter_assembly_drop_multiple_files() (localctx IAlter_assembly_drop_multiple_filesContext)

func (*TSqlParser) Alter_assembly_file_bits

func (p *TSqlParser) Alter_assembly_file_bits() (localctx IAlter_assembly_file_bitsContext)

func (*TSqlParser) Alter_assembly_file_name

func (p *TSqlParser) Alter_assembly_file_name() (localctx IAlter_assembly_file_nameContext)

func (*TSqlParser) Alter_assembly_from_clause

func (p *TSqlParser) Alter_assembly_from_clause() (localctx IAlter_assembly_from_clauseContext)

func (*TSqlParser) Alter_assembly_from_clause_start

func (p *TSqlParser) Alter_assembly_from_clause_start() (localctx IAlter_assembly_from_clause_startContext)

func (*TSqlParser) Alter_assembly_start

func (p *TSqlParser) Alter_assembly_start() (localctx IAlter_assembly_startContext)

func (*TSqlParser) Alter_assembly_with

func (p *TSqlParser) Alter_assembly_with() (localctx IAlter_assembly_withContext)

func (*TSqlParser) Alter_assembly_with_clause

func (p *TSqlParser) Alter_assembly_with_clause() (localctx IAlter_assembly_with_clauseContext)

func (*TSqlParser) Alter_asssembly_add_clause_start

func (p *TSqlParser) Alter_asssembly_add_clause_start() (localctx IAlter_asssembly_add_clause_startContext)

func (*TSqlParser) Alter_asymmetric_key

func (p *TSqlParser) Alter_asymmetric_key() (localctx IAlter_asymmetric_keyContext)

func (*TSqlParser) Alter_asymmetric_key_start

func (p *TSqlParser) Alter_asymmetric_key_start() (localctx IAlter_asymmetric_key_startContext)

func (*TSqlParser) Alter_authorization

func (p *TSqlParser) Alter_authorization() (localctx IAlter_authorizationContext)

func (*TSqlParser) Alter_authorization_for_azure_dw

func (p *TSqlParser) Alter_authorization_for_azure_dw() (localctx IAlter_authorization_for_azure_dwContext)

func (*TSqlParser) Alter_authorization_for_parallel_dw

func (p *TSqlParser) Alter_authorization_for_parallel_dw() (localctx IAlter_authorization_for_parallel_dwContext)

func (*TSqlParser) Alter_authorization_for_sql_database

func (p *TSqlParser) Alter_authorization_for_sql_database() (localctx IAlter_authorization_for_sql_databaseContext)

func (*TSqlParser) Alter_authorization_start

func (p *TSqlParser) Alter_authorization_start() (localctx IAlter_authorization_startContext)

func (*TSqlParser) Alter_availability_group

func (p *TSqlParser) Alter_availability_group() (localctx IAlter_availability_groupContext)

func (*TSqlParser) Alter_availability_group_options

func (p *TSqlParser) Alter_availability_group_options() (localctx IAlter_availability_group_optionsContext)

func (*TSqlParser) Alter_availability_group_start

func (p *TSqlParser) Alter_availability_group_start() (localctx IAlter_availability_group_startContext)

func (*TSqlParser) Alter_certificate

func (p *TSqlParser) Alter_certificate() (localctx IAlter_certificateContext)

func (*TSqlParser) Alter_column_encryption_key

func (p *TSqlParser) Alter_column_encryption_key() (localctx IAlter_column_encryption_keyContext)

func (*TSqlParser) Alter_credential

func (p *TSqlParser) Alter_credential() (localctx IAlter_credentialContext)

func (*TSqlParser) Alter_cryptographic_provider

func (p *TSqlParser) Alter_cryptographic_provider() (localctx IAlter_cryptographic_providerContext)

func (*TSqlParser) Alter_database

func (p *TSqlParser) Alter_database() (localctx IAlter_databaseContext)

func (*TSqlParser) Alter_db_role

func (p *TSqlParser) Alter_db_role() (localctx IAlter_db_roleContext)

func (*TSqlParser) Alter_endpoint

func (p *TSqlParser) Alter_endpoint() (localctx IAlter_endpointContext)

func (*TSqlParser) Alter_external_data_source

func (p *TSqlParser) Alter_external_data_source() (localctx IAlter_external_data_sourceContext)

func (*TSqlParser) Alter_external_library

func (p *TSqlParser) Alter_external_library() (localctx IAlter_external_libraryContext)

func (*TSqlParser) Alter_external_resource_pool

func (p *TSqlParser) Alter_external_resource_pool() (localctx IAlter_external_resource_poolContext)

func (*TSqlParser) Alter_fulltext_catalog

func (p *TSqlParser) Alter_fulltext_catalog() (localctx IAlter_fulltext_catalogContext)

func (*TSqlParser) Alter_fulltext_stoplist

func (p *TSqlParser) Alter_fulltext_stoplist() (localctx IAlter_fulltext_stoplistContext)

func (*TSqlParser) Alter_login_azure_sql

func (p *TSqlParser) Alter_login_azure_sql() (localctx IAlter_login_azure_sqlContext)

func (*TSqlParser) Alter_login_azure_sql_dw_and_pdw

func (p *TSqlParser) Alter_login_azure_sql_dw_and_pdw() (localctx IAlter_login_azure_sql_dw_and_pdwContext)

func (*TSqlParser) Alter_login_sql_server

func (p *TSqlParser) Alter_login_sql_server() (localctx IAlter_login_sql_serverContext)

func (*TSqlParser) Alter_master_key_azure_sql

func (p *TSqlParser) Alter_master_key_azure_sql() (localctx IAlter_master_key_azure_sqlContext)

func (*TSqlParser) Alter_master_key_sql_server

func (p *TSqlParser) Alter_master_key_sql_server() (localctx IAlter_master_key_sql_serverContext)

func (*TSqlParser) Alter_message_type

func (p *TSqlParser) Alter_message_type() (localctx IAlter_message_typeContext)

func (*TSqlParser) Alter_partition_function

func (p *TSqlParser) Alter_partition_function() (localctx IAlter_partition_functionContext)

func (*TSqlParser) Alter_partition_scheme

func (p *TSqlParser) Alter_partition_scheme() (localctx IAlter_partition_schemeContext)

func (*TSqlParser) Alter_queue

func (p *TSqlParser) Alter_queue() (localctx IAlter_queueContext)

func (*TSqlParser) Alter_remote_service_binding

func (p *TSqlParser) Alter_remote_service_binding() (localctx IAlter_remote_service_bindingContext)

func (*TSqlParser) Alter_resource_governor

func (p *TSqlParser) Alter_resource_governor() (localctx IAlter_resource_governorContext)

func (*TSqlParser) Alter_schema_azure_sql_dw_and_pdw

func (p *TSqlParser) Alter_schema_azure_sql_dw_and_pdw() (localctx IAlter_schema_azure_sql_dw_and_pdwContext)

func (*TSqlParser) Alter_schema_sql

func (p *TSqlParser) Alter_schema_sql() (localctx IAlter_schema_sqlContext)

func (*TSqlParser) Alter_sequence

func (p *TSqlParser) Alter_sequence() (localctx IAlter_sequenceContext)

func (*TSqlParser) Alter_server_audit

func (p *TSqlParser) Alter_server_audit() (localctx IAlter_server_auditContext)

func (*TSqlParser) Alter_server_audit_specification

func (p *TSqlParser) Alter_server_audit_specification() (localctx IAlter_server_audit_specificationContext)

func (*TSqlParser) Alter_server_configuration

func (p *TSqlParser) Alter_server_configuration() (localctx IAlter_server_configurationContext)

func (*TSqlParser) Alter_server_role

func (p *TSqlParser) Alter_server_role() (localctx IAlter_server_roleContext)

func (*TSqlParser) Alter_server_role_pdw

func (p *TSqlParser) Alter_server_role_pdw() (localctx IAlter_server_role_pdwContext)

func (*TSqlParser) Alter_service

func (p *TSqlParser) Alter_service() (localctx IAlter_serviceContext)

func (*TSqlParser) Alter_service_master_key

func (p *TSqlParser) Alter_service_master_key() (localctx IAlter_service_master_keyContext)

func (*TSqlParser) Alter_symmetric_key

func (p *TSqlParser) Alter_symmetric_key() (localctx IAlter_symmetric_keyContext)

func (*TSqlParser) Alter_table

func (p *TSqlParser) Alter_table() (localctx IAlter_tableContext)

func (*TSqlParser) Alter_user

func (p *TSqlParser) Alter_user() (localctx IAlter_userContext)

func (*TSqlParser) Alter_user_azure_sql

func (p *TSqlParser) Alter_user_azure_sql() (localctx IAlter_user_azure_sqlContext)

func (*TSqlParser) Alter_workload_group

func (p *TSqlParser) Alter_workload_group() (localctx IAlter_workload_groupContext)

func (*TSqlParser) Analytic_windowed_function

func (p *TSqlParser) Analytic_windowed_function() (localctx IAnalytic_windowed_functionContext)

func (*TSqlParser) Another_statement

func (p *TSqlParser) Another_statement() (localctx IAnother_statementContext)

func (*TSqlParser) As_column_alias

func (p *TSqlParser) As_column_alias() (localctx IAs_column_aliasContext)

func (*TSqlParser) As_table_alias

func (p *TSqlParser) As_table_alias() (localctx IAs_table_aliasContext)

func (*TSqlParser) Assembly_option

func (p *TSqlParser) Assembly_option() (localctx IAssembly_optionContext)

func (*TSqlParser) Assembly_option_Sempred

func (p *TSqlParser) Assembly_option_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*TSqlParser) Assignment_operator

func (p *TSqlParser) Assignment_operator() (localctx IAssignment_operatorContext)

func (*TSqlParser) Asterisk

func (p *TSqlParser) Asterisk() (localctx IAsteriskContext)

func (*TSqlParser) Asymmetric_key_option

func (p *TSqlParser) Asymmetric_key_option() (localctx IAsymmetric_key_optionContext)

func (*TSqlParser) Asymmetric_key_option_start

func (p *TSqlParser) Asymmetric_key_option_start() (localctx IAsymmetric_key_option_startContext)

func (*TSqlParser) Asymmetric_key_password_change_option

func (p *TSqlParser) Asymmetric_key_password_change_option() (localctx IAsymmetric_key_password_change_optionContext)

func (*TSqlParser) Authorization_grantee

func (p *TSqlParser) Authorization_grantee() (localctx IAuthorization_granteeContext)

func (*TSqlParser) Auto_option

func (p *TSqlParser) Auto_option() (localctx IAuto_optionContext)

func (*TSqlParser) Backup_certificate

func (p *TSqlParser) Backup_certificate() (localctx IBackup_certificateContext)

func (*TSqlParser) Backup_database

func (p *TSqlParser) Backup_database() (localctx IBackup_databaseContext)

func (*TSqlParser) Backup_log

func (p *TSqlParser) Backup_log() (localctx IBackup_logContext)

func (*TSqlParser) Backup_master_key

func (p *TSqlParser) Backup_master_key() (localctx IBackup_master_keyContext)

func (*TSqlParser) Backup_service_master_key

func (p *TSqlParser) Backup_service_master_key() (localctx IBackup_service_master_keyContext)

func (*TSqlParser) Backup_statement

func (p *TSqlParser) Backup_statement() (localctx IBackup_statementContext)

func (*TSqlParser) Batch

func (p *TSqlParser) Batch() (localctx IBatchContext)

func (*TSqlParser) Begin_conversation_dialog

func (p *TSqlParser) Begin_conversation_dialog() (localctx IBegin_conversation_dialogContext)

func (*TSqlParser) Begin_conversation_timer

func (p *TSqlParser) Begin_conversation_timer() (localctx IBegin_conversation_timerContext)

func (*TSqlParser) Block_statement

func (p *TSqlParser) Block_statement() (localctx IBlock_statementContext)

func (*TSqlParser) Bracket_expression

func (p *TSqlParser) Bracket_expression() (localctx IBracket_expressionContext)

func (*TSqlParser) Break_statement

func (p *TSqlParser) Break_statement() (localctx IBreak_statementContext)

func (*TSqlParser) Bulk_option

func (p *TSqlParser) Bulk_option() (localctx IBulk_optionContext)

func (*TSqlParser) Case_expression

func (p *TSqlParser) Case_expression() (localctx ICase_expressionContext)

func (*TSqlParser) Cfl_statement

func (p *TSqlParser) Cfl_statement() (localctx ICfl_statementContext)

func (*TSqlParser) Change_table

func (p *TSqlParser) Change_table() (localctx IChange_tableContext)

func (*TSqlParser) Change_tracking_option

func (p *TSqlParser) Change_tracking_option() (localctx IChange_tracking_optionContext)

func (*TSqlParser) Change_tracking_option_list

func (p *TSqlParser) Change_tracking_option_list() (localctx IChange_tracking_option_listContext)

func (*TSqlParser) Class_type

func (p *TSqlParser) Class_type() (localctx IClass_typeContext)

func (*TSqlParser) Class_type_for_azure_dw

func (p *TSqlParser) Class_type_for_azure_dw() (localctx IClass_type_for_azure_dwContext)

func (*TSqlParser) Class_type_for_parallel_dw

func (p *TSqlParser) Class_type_for_parallel_dw() (localctx IClass_type_for_parallel_dwContext)

func (*TSqlParser) Class_type_for_sql_database

func (p *TSqlParser) Class_type_for_sql_database() (localctx IClass_type_for_sql_databaseContext)

func (*TSqlParser) Client_assembly_specifier

func (p *TSqlParser) Client_assembly_specifier() (localctx IClient_assembly_specifierContext)

func (*TSqlParser) Close_key

func (p *TSqlParser) Close_key() (localctx IClose_keyContext)

func (*TSqlParser) Clustered

func (p *TSqlParser) Clustered() (localctx IClusteredContext)

func (*TSqlParser) Colon_colon

func (p *TSqlParser) Colon_colon() (localctx IColon_colonContext)

func (*TSqlParser) Column_alias

func (p *TSqlParser) Column_alias() (localctx IColumn_aliasContext)

func (*TSqlParser) Column_alias_list

func (p *TSqlParser) Column_alias_list() (localctx IColumn_alias_listContext)

func (*TSqlParser) Column_constraint

func (p *TSqlParser) Column_constraint() (localctx IColumn_constraintContext)

func (*TSqlParser) Column_declaration

func (p *TSqlParser) Column_declaration() (localctx IColumn_declarationContext)

func (*TSqlParser) Column_def_table_constraint

func (p *TSqlParser) Column_def_table_constraint() (localctx IColumn_def_table_constraintContext)

func (*TSqlParser) Column_def_table_constraints

func (p *TSqlParser) Column_def_table_constraints() (localctx IColumn_def_table_constraintsContext)

func (*TSqlParser) Column_definition

func (p *TSqlParser) Column_definition() (localctx IColumn_definitionContext)

func (*TSqlParser) Column_elem

func (p *TSqlParser) Column_elem() (localctx IColumn_elemContext)

func (*TSqlParser) Column_name_list

func (p *TSqlParser) Column_name_list() (localctx IColumn_name_listContext)

func (*TSqlParser) Column_name_list_with_order

func (p *TSqlParser) Column_name_list_with_order() (localctx IColumn_name_list_with_orderContext)

func (*TSqlParser) Common_table_expression

func (p *TSqlParser) Common_table_expression() (localctx ICommon_table_expressionContext)

func (*TSqlParser) Comparison_operator

func (p *TSqlParser) Comparison_operator() (localctx IComparison_operatorContext)

func (*TSqlParser) Constant

func (p *TSqlParser) Constant() (localctx IConstantContext)

func (*TSqlParser) Constant_LOCAL_ID

func (p *TSqlParser) Constant_LOCAL_ID() (localctx IConstant_LOCAL_IDContext)

func (*TSqlParser) Constant_expression

func (p *TSqlParser) Constant_expression() (localctx IConstant_expressionContext)

func (*TSqlParser) Containment_option

func (p *TSqlParser) Containment_option() (localctx IContainment_optionContext)

func (*TSqlParser) Continue_statement

func (p *TSqlParser) Continue_statement() (localctx IContinue_statementContext)

func (*TSqlParser) Contract_name

func (p *TSqlParser) Contract_name() (localctx IContract_nameContext)

func (*TSqlParser) Conversation_statement

func (p *TSqlParser) Conversation_statement() (localctx IConversation_statementContext)

func (*TSqlParser) Create_application_role

func (p *TSqlParser) Create_application_role() (localctx ICreate_application_roleContext)

func (*TSqlParser) Create_assembly

func (p *TSqlParser) Create_assembly() (localctx ICreate_assemblyContext)

func (*TSqlParser) Create_asymmetric_key

func (p *TSqlParser) Create_asymmetric_key() (localctx ICreate_asymmetric_keyContext)

func (*TSqlParser) Create_certificate

func (p *TSqlParser) Create_certificate() (localctx ICreate_certificateContext)

func (*TSqlParser) Create_column_encryption_key

func (p *TSqlParser) Create_column_encryption_key() (localctx ICreate_column_encryption_keyContext)

func (*TSqlParser) Create_column_master_key

func (p *TSqlParser) Create_column_master_key() (localctx ICreate_column_master_keyContext)

func (*TSqlParser) Create_contract

func (p *TSqlParser) Create_contract() (localctx ICreate_contractContext)

func (*TSqlParser) Create_credential

func (p *TSqlParser) Create_credential() (localctx ICreate_credentialContext)

func (*TSqlParser) Create_cryptographic_provider

func (p *TSqlParser) Create_cryptographic_provider() (localctx ICreate_cryptographic_providerContext)

func (*TSqlParser) Create_database

func (p *TSqlParser) Create_database() (localctx ICreate_databaseContext)

func (*TSqlParser) Create_database_option

func (p *TSqlParser) Create_database_option() (localctx ICreate_database_optionContext)

func (*TSqlParser) Create_db_role

func (p *TSqlParser) Create_db_role() (localctx ICreate_db_roleContext)

func (*TSqlParser) Create_event_notification

func (p *TSqlParser) Create_event_notification() (localctx ICreate_event_notificationContext)

func (*TSqlParser) Create_external_library

func (p *TSqlParser) Create_external_library() (localctx ICreate_external_libraryContext)

func (*TSqlParser) Create_external_resource_pool

func (p *TSqlParser) Create_external_resource_pool() (localctx ICreate_external_resource_poolContext)

func (*TSqlParser) Create_fulltext_catalog

func (p *TSqlParser) Create_fulltext_catalog() (localctx ICreate_fulltext_catalogContext)

func (*TSqlParser) Create_fulltext_stoplist

func (p *TSqlParser) Create_fulltext_stoplist() (localctx ICreate_fulltext_stoplistContext)

func (*TSqlParser) Create_index

func (p *TSqlParser) Create_index() (localctx ICreate_indexContext)

func (*TSqlParser) Create_key

func (p *TSqlParser) Create_key() (localctx ICreate_keyContext)

func (*TSqlParser) Create_login_azure_sql

func (p *TSqlParser) Create_login_azure_sql() (localctx ICreate_login_azure_sqlContext)

func (*TSqlParser) Create_login_pdw

func (p *TSqlParser) Create_login_pdw() (localctx ICreate_login_pdwContext)

func (*TSqlParser) Create_login_sql_server

func (p *TSqlParser) Create_login_sql_server() (localctx ICreate_login_sql_serverContext)

func (*TSqlParser) Create_master_key_azure_sql

func (p *TSqlParser) Create_master_key_azure_sql() (localctx ICreate_master_key_azure_sqlContext)

func (*TSqlParser) Create_master_key_sql_server

func (p *TSqlParser) Create_master_key_sql_server() (localctx ICreate_master_key_sql_serverContext)

func (*TSqlParser) Create_or_alter_broker_priority

func (p *TSqlParser) Create_or_alter_broker_priority() (localctx ICreate_or_alter_broker_priorityContext)

func (*TSqlParser) Create_or_alter_ddl_trigger

func (p *TSqlParser) Create_or_alter_ddl_trigger() (localctx ICreate_or_alter_ddl_triggerContext)

func (*TSqlParser) Create_or_alter_dml_trigger

func (p *TSqlParser) Create_or_alter_dml_trigger() (localctx ICreate_or_alter_dml_triggerContext)

func (*TSqlParser) Create_or_alter_event_session

func (p *TSqlParser) Create_or_alter_event_session() (localctx ICreate_or_alter_event_sessionContext)

func (*TSqlParser) Create_or_alter_function

func (p *TSqlParser) Create_or_alter_function() (localctx ICreate_or_alter_functionContext)

func (*TSqlParser) Create_or_alter_procedure

func (p *TSqlParser) Create_or_alter_procedure() (localctx ICreate_or_alter_procedureContext)

func (*TSqlParser) Create_or_alter_trigger

func (p *TSqlParser) Create_or_alter_trigger() (localctx ICreate_or_alter_triggerContext)

func (*TSqlParser) Create_queue

func (p *TSqlParser) Create_queue() (localctx ICreate_queueContext)

func (*TSqlParser) Create_remote_service_binding

func (p *TSqlParser) Create_remote_service_binding() (localctx ICreate_remote_service_bindingContext)

func (*TSqlParser) Create_resource_pool

func (p *TSqlParser) Create_resource_pool() (localctx ICreate_resource_poolContext)

func (*TSqlParser) Create_route

func (p *TSqlParser) Create_route() (localctx ICreate_routeContext)

func (*TSqlParser) Create_rule

func (p *TSqlParser) Create_rule() (localctx ICreate_ruleContext)

func (*TSqlParser) Create_schema

func (p *TSqlParser) Create_schema() (localctx ICreate_schemaContext)

func (*TSqlParser) Create_schema_azure_sql_dw_and_pdw

func (p *TSqlParser) Create_schema_azure_sql_dw_and_pdw() (localctx ICreate_schema_azure_sql_dw_and_pdwContext)

func (*TSqlParser) Create_search_property_list

func (p *TSqlParser) Create_search_property_list() (localctx ICreate_search_property_listContext)

func (*TSqlParser) Create_security_policy

func (p *TSqlParser) Create_security_policy() (localctx ICreate_security_policyContext)

func (*TSqlParser) Create_sequence

func (p *TSqlParser) Create_sequence() (localctx ICreate_sequenceContext)

func (*TSqlParser) Create_server_audit

func (p *TSqlParser) Create_server_audit() (localctx ICreate_server_auditContext)

func (*TSqlParser) Create_server_audit_specification

func (p *TSqlParser) Create_server_audit_specification() (localctx ICreate_server_audit_specificationContext)

func (*TSqlParser) Create_server_role

func (p *TSqlParser) Create_server_role() (localctx ICreate_server_roleContext)

func (*TSqlParser) Create_service

func (p *TSqlParser) Create_service() (localctx ICreate_serviceContext)

func (*TSqlParser) Create_statistics

func (p *TSqlParser) Create_statistics() (localctx ICreate_statisticsContext)

func (*TSqlParser) Create_symmetric_key

func (p *TSqlParser) Create_symmetric_key() (localctx ICreate_symmetric_keyContext)

func (*TSqlParser) Create_synonym

func (p *TSqlParser) Create_synonym() (localctx ICreate_synonymContext)

func (*TSqlParser) Create_table

func (p *TSqlParser) Create_table() (localctx ICreate_tableContext)

func (*TSqlParser) Create_type

func (p *TSqlParser) Create_type() (localctx ICreate_typeContext)

func (*TSqlParser) Create_user

func (p *TSqlParser) Create_user() (localctx ICreate_userContext)

func (*TSqlParser) Create_user_azure_sql_dw

func (p *TSqlParser) Create_user_azure_sql_dw() (localctx ICreate_user_azure_sql_dwContext)

func (*TSqlParser) Create_view

func (p *TSqlParser) Create_view() (localctx ICreate_viewContext)

func (*TSqlParser) Create_workload_group

func (p *TSqlParser) Create_workload_group() (localctx ICreate_workload_groupContext)

func (*TSqlParser) Create_xml_schema_collection

func (p *TSqlParser) Create_xml_schema_collection() (localctx ICreate_xml_schema_collectionContext)

func (*TSqlParser) Cursor_name

func (p *TSqlParser) Cursor_name() (localctx ICursor_nameContext)

func (*TSqlParser) Cursor_option

func (p *TSqlParser) Cursor_option() (localctx ICursor_optionContext)

func (*TSqlParser) Cursor_statement

func (p *TSqlParser) Cursor_statement() (localctx ICursor_statementContext)

func (*TSqlParser) Data_type

func (p *TSqlParser) Data_type() (localctx IData_typeContext)

func (*TSqlParser) Database_file_spec

func (p *TSqlParser) Database_file_spec() (localctx IDatabase_file_specContext)

func (*TSqlParser) Database_filestream_option

func (p *TSqlParser) Database_filestream_option() (localctx IDatabase_filestream_optionContext)

func (*TSqlParser) Database_mirroring_option

func (p *TSqlParser) Database_mirroring_option() (localctx IDatabase_mirroring_optionContext)

func (*TSqlParser) Database_optionspec

func (p *TSqlParser) Database_optionspec() (localctx IDatabase_optionspecContext)

func (*TSqlParser) Date_correlation_optimization_option

func (p *TSqlParser) Date_correlation_optimization_option() (localctx IDate_correlation_optimization_optionContext)

func (*TSqlParser) Date_options

func (p *TSqlParser) Date_options() (localctx IDate_optionsContext)

func (*TSqlParser) Db_encryption_option

func (p *TSqlParser) Db_encryption_option() (localctx IDb_encryption_optionContext)

func (*TSqlParser) Db_state_option

func (p *TSqlParser) Db_state_option() (localctx IDb_state_optionContext)

func (*TSqlParser) Db_update_option

func (p *TSqlParser) Db_update_option() (localctx IDb_update_optionContext)

func (*TSqlParser) Db_user_access_option

func (p *TSqlParser) Db_user_access_option() (localctx IDb_user_access_optionContext)

func (*TSqlParser) Dbcc_clause

func (p *TSqlParser) Dbcc_clause() (localctx IDbcc_clauseContext)

func (*TSqlParser) Dbcc_options

func (p *TSqlParser) Dbcc_options() (localctx IDbcc_optionsContext)

func (*TSqlParser) Ddl_clause

func (p *TSqlParser) Ddl_clause() (localctx IDdl_clauseContext)

func (*TSqlParser) Ddl_object

func (p *TSqlParser) Ddl_object() (localctx IDdl_objectContext)

func (*TSqlParser) Ddl_trigger_operation

func (p *TSqlParser) Ddl_trigger_operation() (localctx IDdl_trigger_operationContext)

func (*TSqlParser) Declare_cursor

func (p *TSqlParser) Declare_cursor() (localctx IDeclare_cursorContext)

func (*TSqlParser) Declare_local

func (p *TSqlParser) Declare_local() (localctx IDeclare_localContext)

func (*TSqlParser) Declare_set_cursor_common

func (p *TSqlParser) Declare_set_cursor_common() (localctx IDeclare_set_cursor_commonContext)

func (*TSqlParser) Declare_set_cursor_common_partial

func (p *TSqlParser) Declare_set_cursor_common_partial() (localctx IDeclare_set_cursor_common_partialContext)

func (*TSqlParser) Declare_statement

func (p *TSqlParser) Declare_statement() (localctx IDeclare_statementContext)

func (*TSqlParser) Decryption_mechanism

func (p *TSqlParser) Decryption_mechanism() (localctx IDecryption_mechanismContext)

func (*TSqlParser) Default_value

func (p *TSqlParser) Default_value() (localctx IDefault_valueContext)

func (*TSqlParser) Delayed_durability_option

func (p *TSqlParser) Delayed_durability_option() (localctx IDelayed_durability_optionContext)

func (*TSqlParser) Delete_statement

func (p *TSqlParser) Delete_statement() (localctx IDelete_statementContext)

func (*TSqlParser) Delete_statement_from

func (p *TSqlParser) Delete_statement_from() (localctx IDelete_statement_fromContext)

func (*TSqlParser) Derived_table

func (p *TSqlParser) Derived_table() (localctx IDerived_tableContext)

func (*TSqlParser) Disable_trigger

func (p *TSqlParser) Disable_trigger() (localctx IDisable_triggerContext)

func (*TSqlParser) Dml_clause

func (p *TSqlParser) Dml_clause() (localctx IDml_clauseContext)

func (*TSqlParser) Dml_trigger_operation

func (p *TSqlParser) Dml_trigger_operation() (localctx IDml_trigger_operationContext)

func (*TSqlParser) Dml_trigger_option

func (p *TSqlParser) Dml_trigger_option() (localctx IDml_trigger_optionContext)

func (*TSqlParser) Drop_aggregate

func (p *TSqlParser) Drop_aggregate() (localctx IDrop_aggregateContext)

func (*TSqlParser) Drop_application_role

func (p *TSqlParser) Drop_application_role() (localctx IDrop_application_roleContext)

func (*TSqlParser) Drop_assembly

func (p *TSqlParser) Drop_assembly() (localctx IDrop_assemblyContext)

func (*TSqlParser) Drop_asymmetric_key

func (p *TSqlParser) Drop_asymmetric_key() (localctx IDrop_asymmetric_keyContext)

func (*TSqlParser) Drop_availability_group

func (p *TSqlParser) Drop_availability_group() (localctx IDrop_availability_groupContext)

func (*TSqlParser) Drop_backward_compatible_index

func (p *TSqlParser) Drop_backward_compatible_index() (localctx IDrop_backward_compatible_indexContext)

func (*TSqlParser) Drop_broker_priority

func (p *TSqlParser) Drop_broker_priority() (localctx IDrop_broker_priorityContext)

func (*TSqlParser) Drop_certificate

func (p *TSqlParser) Drop_certificate() (localctx IDrop_certificateContext)

func (*TSqlParser) Drop_column_encryption_key

func (p *TSqlParser) Drop_column_encryption_key() (localctx IDrop_column_encryption_keyContext)

func (*TSqlParser) Drop_column_master_key

func (p *TSqlParser) Drop_column_master_key() (localctx IDrop_column_master_keyContext)

func (*TSqlParser) Drop_contract

func (p *TSqlParser) Drop_contract() (localctx IDrop_contractContext)

func (*TSqlParser) Drop_credential

func (p *TSqlParser) Drop_credential() (localctx IDrop_credentialContext)

func (*TSqlParser) Drop_cryptograhic_provider

func (p *TSqlParser) Drop_cryptograhic_provider() (localctx IDrop_cryptograhic_providerContext)

func (*TSqlParser) Drop_database

func (p *TSqlParser) Drop_database() (localctx IDrop_databaseContext)

func (*TSqlParser) Drop_database_audit_specification

func (p *TSqlParser) Drop_database_audit_specification() (localctx IDrop_database_audit_specificationContext)

func (*TSqlParser) Drop_database_scoped_credential

func (p *TSqlParser) Drop_database_scoped_credential() (localctx IDrop_database_scoped_credentialContext)

func (*TSqlParser) Drop_db_role

func (p *TSqlParser) Drop_db_role() (localctx IDrop_db_roleContext)

func (*TSqlParser) Drop_ddl_trigger

func (p *TSqlParser) Drop_ddl_trigger() (localctx IDrop_ddl_triggerContext)

func (*TSqlParser) Drop_default

func (p *TSqlParser) Drop_default() (localctx IDrop_defaultContext)

func (*TSqlParser) Drop_dml_trigger

func (p *TSqlParser) Drop_dml_trigger() (localctx IDrop_dml_triggerContext)

func (*TSqlParser) Drop_endpoint

func (p *TSqlParser) Drop_endpoint() (localctx IDrop_endpointContext)

func (*TSqlParser) Drop_event_notifications

func (p *TSqlParser) Drop_event_notifications() (localctx IDrop_event_notificationsContext)

func (*TSqlParser) Drop_event_session

func (p *TSqlParser) Drop_event_session() (localctx IDrop_event_sessionContext)

func (*TSqlParser) Drop_external_data_source

func (p *TSqlParser) Drop_external_data_source() (localctx IDrop_external_data_sourceContext)

func (*TSqlParser) Drop_external_file_format

func (p *TSqlParser) Drop_external_file_format() (localctx IDrop_external_file_formatContext)

func (*TSqlParser) Drop_external_library

func (p *TSqlParser) Drop_external_library() (localctx IDrop_external_libraryContext)

func (*TSqlParser) Drop_external_resource_pool

func (p *TSqlParser) Drop_external_resource_pool() (localctx IDrop_external_resource_poolContext)

func (*TSqlParser) Drop_external_table

func (p *TSqlParser) Drop_external_table() (localctx IDrop_external_tableContext)

func (*TSqlParser) Drop_fulltext_catalog

func (p *TSqlParser) Drop_fulltext_catalog() (localctx IDrop_fulltext_catalogContext)

func (*TSqlParser) Drop_fulltext_index

func (p *TSqlParser) Drop_fulltext_index() (localctx IDrop_fulltext_indexContext)

func (*TSqlParser) Drop_fulltext_stoplist

func (p *TSqlParser) Drop_fulltext_stoplist() (localctx IDrop_fulltext_stoplistContext)

func (*TSqlParser) Drop_function

func (p *TSqlParser) Drop_function() (localctx IDrop_functionContext)

func (*TSqlParser) Drop_index

func (p *TSqlParser) Drop_index() (localctx IDrop_indexContext)

func (*TSqlParser) Drop_login

func (p *TSqlParser) Drop_login() (localctx IDrop_loginContext)

func (*TSqlParser) Drop_master_key

func (p *TSqlParser) Drop_master_key() (localctx IDrop_master_keyContext)

func (*TSqlParser) Drop_message_type

func (p *TSqlParser) Drop_message_type() (localctx IDrop_message_typeContext)

func (*TSqlParser) Drop_partition_function

func (p *TSqlParser) Drop_partition_function() (localctx IDrop_partition_functionContext)

func (*TSqlParser) Drop_partition_scheme

func (p *TSqlParser) Drop_partition_scheme() (localctx IDrop_partition_schemeContext)

func (*TSqlParser) Drop_procedure

func (p *TSqlParser) Drop_procedure() (localctx IDrop_procedureContext)

func (*TSqlParser) Drop_queue

func (p *TSqlParser) Drop_queue() (localctx IDrop_queueContext)

func (*TSqlParser) Drop_relational_or_xml_or_spatial_index

func (p *TSqlParser) Drop_relational_or_xml_or_spatial_index() (localctx IDrop_relational_or_xml_or_spatial_indexContext)

func (*TSqlParser) Drop_remote_service_binding

func (p *TSqlParser) Drop_remote_service_binding() (localctx IDrop_remote_service_bindingContext)

func (*TSqlParser) Drop_resource_pool

func (p *TSqlParser) Drop_resource_pool() (localctx IDrop_resource_poolContext)

func (*TSqlParser) Drop_route

func (p *TSqlParser) Drop_route() (localctx IDrop_routeContext)

func (*TSqlParser) Drop_rule

func (p *TSqlParser) Drop_rule() (localctx IDrop_ruleContext)

func (*TSqlParser) Drop_schema

func (p *TSqlParser) Drop_schema() (localctx IDrop_schemaContext)

func (*TSqlParser) Drop_search_property_list

func (p *TSqlParser) Drop_search_property_list() (localctx IDrop_search_property_listContext)

func (*TSqlParser) Drop_security_policy

func (p *TSqlParser) Drop_security_policy() (localctx IDrop_security_policyContext)

func (*TSqlParser) Drop_sequence

func (p *TSqlParser) Drop_sequence() (localctx IDrop_sequenceContext)

func (*TSqlParser) Drop_server_audit

func (p *TSqlParser) Drop_server_audit() (localctx IDrop_server_auditContext)

func (*TSqlParser) Drop_server_audit_specification

func (p *TSqlParser) Drop_server_audit_specification() (localctx IDrop_server_audit_specificationContext)

func (*TSqlParser) Drop_server_role

func (p *TSqlParser) Drop_server_role() (localctx IDrop_server_roleContext)

func (*TSqlParser) Drop_service

func (p *TSqlParser) Drop_service() (localctx IDrop_serviceContext)

func (*TSqlParser) Drop_signature

func (p *TSqlParser) Drop_signature() (localctx IDrop_signatureContext)

func (*TSqlParser) Drop_statistics

func (p *TSqlParser) Drop_statistics() (localctx IDrop_statisticsContext)

func (*TSqlParser) Drop_statistics_name_azure_dw_and_pdw

func (p *TSqlParser) Drop_statistics_name_azure_dw_and_pdw() (localctx IDrop_statistics_name_azure_dw_and_pdwContext)

func (*TSqlParser) Drop_symmetric_key

func (p *TSqlParser) Drop_symmetric_key() (localctx IDrop_symmetric_keyContext)

func (*TSqlParser) Drop_synonym

func (p *TSqlParser) Drop_synonym() (localctx IDrop_synonymContext)

func (*TSqlParser) Drop_table

func (p *TSqlParser) Drop_table() (localctx IDrop_tableContext)

func (*TSqlParser) Drop_trigger

func (p *TSqlParser) Drop_trigger() (localctx IDrop_triggerContext)

func (*TSqlParser) Drop_type

func (p *TSqlParser) Drop_type() (localctx IDrop_typeContext)

func (*TSqlParser) Drop_user

func (p *TSqlParser) Drop_user() (localctx IDrop_userContext)

func (*TSqlParser) Drop_view

func (p *TSqlParser) Drop_view() (localctx IDrop_viewContext)

func (*TSqlParser) Drop_workload_group

func (p *TSqlParser) Drop_workload_group() (localctx IDrop_workload_groupContext)

func (*TSqlParser) Drop_xml_schema_collection

func (p *TSqlParser) Drop_xml_schema_collection() (localctx IDrop_xml_schema_collectionContext)

func (*TSqlParser) Empty_statement

func (p *TSqlParser) Empty_statement() (localctx IEmpty_statementContext)

func (*TSqlParser) Enable_trigger

func (p *TSqlParser) Enable_trigger() (localctx IEnable_triggerContext)

func (*TSqlParser) Encryption_mechanism

func (p *TSqlParser) Encryption_mechanism() (localctx IEncryption_mechanismContext)

func (*TSqlParser) End_conversation

func (p *TSqlParser) End_conversation() (localctx IEnd_conversationContext)

func (*TSqlParser) Entity_name

func (p *TSqlParser) Entity_name() (localctx IEntity_nameContext)

func (*TSqlParser) Entity_name_for_azure_dw

func (p *TSqlParser) Entity_name_for_azure_dw() (localctx IEntity_name_for_azure_dwContext)

func (*TSqlParser) Entity_name_for_parallel_dw

func (p *TSqlParser) Entity_name_for_parallel_dw() (localctx IEntity_name_for_parallel_dwContext)

func (*TSqlParser) Entity_to

func (p *TSqlParser) Entity_to() (localctx IEntity_toContext)

func (*TSqlParser) Event_session_predicate_expression

func (p *TSqlParser) Event_session_predicate_expression() (localctx IEvent_session_predicate_expressionContext)

func (*TSqlParser) Event_session_predicate_factor

func (p *TSqlParser) Event_session_predicate_factor() (localctx IEvent_session_predicate_factorContext)

func (*TSqlParser) Event_session_predicate_leaf

func (p *TSqlParser) Event_session_predicate_leaf() (localctx IEvent_session_predicate_leafContext)

func (*TSqlParser) Execute_body

func (p *TSqlParser) Execute_body() (localctx IExecute_bodyContext)

func (*TSqlParser) Execute_clause

func (p *TSqlParser) Execute_clause() (localctx IExecute_clauseContext)

func (*TSqlParser) Execute_statement

func (p *TSqlParser) Execute_statement() (localctx IExecute_statementContext)

func (*TSqlParser) Execute_statement_arg

func (p *TSqlParser) Execute_statement_arg() (localctx IExecute_statement_argContext)

func (*TSqlParser) Execute_var_string

func (p *TSqlParser) Execute_var_string() (localctx IExecute_var_stringContext)

func (*TSqlParser) Exist_method

func (p *TSqlParser) Exist_method() (localctx IExist_methodContext)

func (*TSqlParser) Existing_keys

func (p *TSqlParser) Existing_keys() (localctx IExisting_keysContext)

func (*TSqlParser) Expression

func (p *TSqlParser) Expression() (localctx IExpressionContext)

func (*TSqlParser) Expression_Sempred

func (p *TSqlParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*TSqlParser) Expression_elem

func (p *TSqlParser) Expression_elem() (localctx IExpression_elemContext)

func (*TSqlParser) Expression_list

func (p *TSqlParser) Expression_list() (localctx IExpression_listContext)

func (*TSqlParser) External_access_option

func (p *TSqlParser) External_access_option() (localctx IExternal_access_optionContext)

func (*TSqlParser) Fetch_cursor

func (p *TSqlParser) Fetch_cursor() (localctx IFetch_cursorContext)

func (*TSqlParser) File_directory_path_separator

func (p *TSqlParser) File_directory_path_separator() (localctx IFile_directory_path_separatorContext)

func (*TSqlParser) File_group

func (p *TSqlParser) File_group() (localctx IFile_groupContext)

func (*TSqlParser) File_path

func (p *TSqlParser) File_path() (localctx IFile_pathContext)

func (*TSqlParser) File_size

func (p *TSqlParser) File_size() (localctx IFile_sizeContext)

func (*TSqlParser) File_spec

func (p *TSqlParser) File_spec() (localctx IFile_specContext)

func (*TSqlParser) For_clause

func (p *TSqlParser) For_clause() (localctx IFor_clauseContext)

func (*TSqlParser) Full_column_name

func (p *TSqlParser) Full_column_name() (localctx IFull_column_nameContext)

func (*TSqlParser) Full_column_name_list

func (p *TSqlParser) Full_column_name_list() (localctx IFull_column_name_listContext)

func (*TSqlParser) Full_table_name

func (p *TSqlParser) Full_table_name() (localctx IFull_table_nameContext)

func (*TSqlParser) Func_body_returns_scalar

func (p *TSqlParser) Func_body_returns_scalar() (localctx IFunc_body_returns_scalarContext)

func (*TSqlParser) Func_body_returns_select

func (p *TSqlParser) Func_body_returns_select() (localctx IFunc_body_returns_selectContext)

func (*TSqlParser) Func_body_returns_table

func (p *TSqlParser) Func_body_returns_table() (localctx IFunc_body_returns_tableContext)

func (*TSqlParser) Func_proc_name_database_schema

func (p *TSqlParser) Func_proc_name_database_schema() (localctx IFunc_proc_name_database_schemaContext)

func (*TSqlParser) Func_proc_name_schema

func (p *TSqlParser) Func_proc_name_schema() (localctx IFunc_proc_name_schemaContext)

func (*TSqlParser) Func_proc_name_server_database_schema

func (p *TSqlParser) Func_proc_name_server_database_schema() (localctx IFunc_proc_name_server_database_schemaContext)

func (*TSqlParser) Function_call

func (p *TSqlParser) Function_call() (localctx IFunction_callContext)

func (*TSqlParser) Function_option

func (p *TSqlParser) Function_option() (localctx IFunction_optionContext)

func (*TSqlParser) Generate_new_keys

func (p *TSqlParser) Generate_new_keys() (localctx IGenerate_new_keysContext)

func (*TSqlParser) Get_conversation

func (p *TSqlParser) Get_conversation() (localctx IGet_conversationContext)

func (*TSqlParser) Go_statement

func (p *TSqlParser) Go_statement() (localctx IGo_statementContext)

func (*TSqlParser) Goto_statement

func (p *TSqlParser) Goto_statement() (localctx IGoto_statementContext)

func (*TSqlParser) Grant_permission

func (p *TSqlParser) Grant_permission() (localctx IGrant_permissionContext)

func (*TSqlParser) Group_by_item

func (p *TSqlParser) Group_by_item() (localctx IGroup_by_itemContext)

func (*TSqlParser) Hadr_options

func (p *TSqlParser) Hadr_options() (localctx IHadr_optionsContext)

func (*TSqlParser) Host

func (p *TSqlParser) Host() (localctx IHostContext)

func (*TSqlParser) Id

func (p *TSqlParser) Id() (localctx IIdContext)

func (*TSqlParser) If_statement

func (p *TSqlParser) If_statement() (localctx IIf_statementContext)

func (*TSqlParser) Index_option

func (p *TSqlParser) Index_option() (localctx IIndex_optionContext)

func (*TSqlParser) Index_options

func (p *TSqlParser) Index_options() (localctx IIndex_optionsContext)

func (*TSqlParser) Index_value

func (p *TSqlParser) Index_value() (localctx IIndex_valueContext)

func (*TSqlParser) Insert_statement

func (p *TSqlParser) Insert_statement() (localctx IInsert_statementContext)

func (*TSqlParser) Insert_statement_value

func (p *TSqlParser) Insert_statement_value() (localctx IInsert_statement_valueContext)

func (*TSqlParser) Insert_with_table_hints

func (p *TSqlParser) Insert_with_table_hints() (localctx IInsert_with_table_hintsContext)

func (*TSqlParser) Join_part

func (p *TSqlParser) Join_part() (localctx IJoin_partContext)

func (*TSqlParser) Key_options

func (p *TSqlParser) Key_options() (localctx IKey_optionsContext)

func (*TSqlParser) Local_drive

func (p *TSqlParser) Local_drive() (localctx ILocal_driveContext)

func (*TSqlParser) Local_file

func (p *TSqlParser) Local_file() (localctx ILocal_fileContext)

func (*TSqlParser) Lock_table

func (p *TSqlParser) Lock_table() (localctx ILock_tableContext)

func (*TSqlParser) Materialized_column_definition

func (p *TSqlParser) Materialized_column_definition() (localctx IMaterialized_column_definitionContext)

func (*TSqlParser) Merge_matched

func (p *TSqlParser) Merge_matched() (localctx IMerge_matchedContext)

func (*TSqlParser) Merge_not_matched

func (p *TSqlParser) Merge_not_matched() (localctx IMerge_not_matchedContext)

func (*TSqlParser) Merge_statement

func (p *TSqlParser) Merge_statement() (localctx IMerge_statementContext)

func (*TSqlParser) Message_statement

func (p *TSqlParser) Message_statement() (localctx IMessage_statementContext)

func (*TSqlParser) Mirroring_host_port_seperator

func (p *TSqlParser) Mirroring_host_port_seperator() (localctx IMirroring_host_port_seperatorContext)

func (*TSqlParser) Mirroring_partner

func (p *TSqlParser) Mirroring_partner() (localctx IMirroring_partnerContext)

func (*TSqlParser) Mirroring_set_option

func (p *TSqlParser) Mirroring_set_option() (localctx IMirroring_set_optionContext)

func (*TSqlParser) Mirroring_witness

func (p *TSqlParser) Mirroring_witness() (localctx IMirroring_witnessContext)

func (*TSqlParser) Mixed_page_allocation_option

func (p *TSqlParser) Mixed_page_allocation_option() (localctx IMixed_page_allocation_optionContext)

func (*TSqlParser) Modify_method

func (p *TSqlParser) Modify_method() (localctx IModify_methodContext)

func (*TSqlParser) Multiple_local_file_start

func (p *TSqlParser) Multiple_local_file_start() (localctx IMultiple_local_file_startContext)

func (*TSqlParser) Multiple_local_files

func (p *TSqlParser) Multiple_local_files() (localctx IMultiple_local_filesContext)

func (*TSqlParser) Network_computer

func (p *TSqlParser) Network_computer() (localctx INetwork_computerContext)

func (*TSqlParser) Network_file_share

func (p *TSqlParser) Network_file_share() (localctx INetwork_file_shareContext)

func (*TSqlParser) Network_file_start

func (p *TSqlParser) Network_file_start() (localctx INetwork_file_startContext)

func (*TSqlParser) Nodes_method

func (p *TSqlParser) Nodes_method() (localctx INodes_methodContext)

func (*TSqlParser) Null_notnull

func (p *TSqlParser) Null_notnull() (localctx INull_notnullContext)

func (*TSqlParser) Null_or_default

func (p *TSqlParser) Null_or_default() (localctx INull_or_defaultContext)

func (*TSqlParser) On_delete

func (p *TSqlParser) On_delete() (localctx IOn_deleteContext)

func (*TSqlParser) On_off

func (p *TSqlParser) On_off() (localctx IOn_offContext)

func (*TSqlParser) On_update

func (p *TSqlParser) On_update() (localctx IOn_updateContext)

func (*TSqlParser) Open_key

func (p *TSqlParser) Open_key() (localctx IOpen_keyContext)

func (*TSqlParser) Open_xml

func (p *TSqlParser) Open_xml() (localctx IOpen_xmlContext)

func (*TSqlParser) Opendatasource

func (p *TSqlParser) Opendatasource() (localctx IOpendatasourceContext)

func (*TSqlParser) Openquery

func (p *TSqlParser) Openquery() (localctx IOpenqueryContext)

func (*TSqlParser) Optimize_for_arg

func (p *TSqlParser) Optimize_for_arg() (localctx IOptimize_for_argContext)

func (*TSqlParser) Option

func (p *TSqlParser) Option() (localctx IOptionContext)

func (*TSqlParser) Option_clause

func (p *TSqlParser) Option_clause() (localctx IOption_clauseContext)

func (*TSqlParser) Order_by_clause

func (p *TSqlParser) Order_by_clause() (localctx IOrder_by_clauseContext)

func (*TSqlParser) Order_by_expression

func (p *TSqlParser) Order_by_expression() (localctx IOrder_by_expressionContext)

func (*TSqlParser) Output_clause

func (p *TSqlParser) Output_clause() (localctx IOutput_clauseContext)

func (*TSqlParser) Output_column_name

func (p *TSqlParser) Output_column_name() (localctx IOutput_column_nameContext)

func (*TSqlParser) Output_dml_list_elem

func (p *TSqlParser) Output_dml_list_elem() (localctx IOutput_dml_list_elemContext)

func (*TSqlParser) Over_clause

func (p *TSqlParser) Over_clause() (localctx IOver_clauseContext)

func (*TSqlParser) Parameterization_option

func (p *TSqlParser) Parameterization_option() (localctx IParameterization_optionContext)

func (*TSqlParser) Partner_option

func (p *TSqlParser) Partner_option() (localctx IPartner_optionContext)

func (*TSqlParser) Partner_server

func (p *TSqlParser) Partner_server() (localctx IPartner_serverContext)

func (*TSqlParser) Partner_server_tcp_prefix

func (p *TSqlParser) Partner_server_tcp_prefix() (localctx IPartner_server_tcp_prefixContext)

func (*TSqlParser) Pivot_clause

func (p *TSqlParser) Pivot_clause() (localctx IPivot_clauseContext)

func (*TSqlParser) Port_number

func (p *TSqlParser) Port_number() (localctx IPort_numberContext)

func (*TSqlParser) Predicate

func (p *TSqlParser) Predicate() (localctx IPredicateContext)

func (*TSqlParser) Primitive_expression

func (p *TSqlParser) Primitive_expression() (localctx IPrimitive_expressionContext)

func (*TSqlParser) Print_statement

func (p *TSqlParser) Print_statement() (localctx IPrint_statementContext)

func (*TSqlParser) Private_key_options

func (p *TSqlParser) Private_key_options() (localctx IPrivate_key_optionsContext)

func (*TSqlParser) Procedure_option

func (p *TSqlParser) Procedure_option() (localctx IProcedure_optionContext)

func (*TSqlParser) Procedure_param

func (p *TSqlParser) Procedure_param() (localctx IProcedure_paramContext)

func (*TSqlParser) Query_expression

func (p *TSqlParser) Query_expression() (localctx IQuery_expressionContext)

func (*TSqlParser) Query_method

func (p *TSqlParser) Query_method() (localctx IQuery_methodContext)

func (*TSqlParser) Query_specification

func (p *TSqlParser) Query_specification() (localctx IQuery_specificationContext)

func (*TSqlParser) Queue_action

func (p *TSqlParser) Queue_action() (localctx IQueue_actionContext)

func (*TSqlParser) Queue_id

func (p *TSqlParser) Queue_id() (localctx IQueue_idContext)

func (*TSqlParser) Queue_rebuild_options

func (p *TSqlParser) Queue_rebuild_options() (localctx IQueue_rebuild_optionsContext)

func (*TSqlParser) Queue_settings

func (p *TSqlParser) Queue_settings() (localctx IQueue_settingsContext)

func (*TSqlParser) Raiseerror_statement

func (p *TSqlParser) Raiseerror_statement() (localctx IRaiseerror_statementContext)

func (*TSqlParser) Ranking_windowed_function

func (p *TSqlParser) Ranking_windowed_function() (localctx IRanking_windowed_functionContext)

func (*TSqlParser) Receive_statement

func (p *TSqlParser) Receive_statement() (localctx IReceive_statementContext)

func (*TSqlParser) Recovery_option

func (p *TSqlParser) Recovery_option() (localctx IRecovery_optionContext)

func (*TSqlParser) Return_statement

func (p *TSqlParser) Return_statement() (localctx IReturn_statementContext)

func (*TSqlParser) Row_or_range_clause

func (p *TSqlParser) Row_or_range_clause() (localctx IRow_or_range_clauseContext)

func (*TSqlParser) Rowset_function

func (p *TSqlParser) Rowset_function() (localctx IRowset_functionContext)

func (*TSqlParser) Rowset_function_limited

func (p *TSqlParser) Rowset_function_limited() (localctx IRowset_function_limitedContext)

func (*TSqlParser) Scalar_function_name

func (p *TSqlParser) Scalar_function_name() (localctx IScalar_function_nameContext)

func (*TSqlParser) Schema_declaration

func (p *TSqlParser) Schema_declaration() (localctx ISchema_declarationContext)

func (*TSqlParser) Search_condition

func (p *TSqlParser) Search_condition() (localctx ISearch_conditionContext)

func (*TSqlParser) Search_condition_and

func (p *TSqlParser) Search_condition_and() (localctx ISearch_condition_andContext)

func (*TSqlParser) Search_condition_list

func (p *TSqlParser) Search_condition_list() (localctx ISearch_condition_listContext)

func (*TSqlParser) Search_condition_not

func (p *TSqlParser) Search_condition_not() (localctx ISearch_condition_notContext)

func (*TSqlParser) Security_statement

func (p *TSqlParser) Security_statement() (localctx ISecurity_statementContext)

func (*TSqlParser) Select_list

func (p *TSqlParser) Select_list() (localctx ISelect_listContext)

func (*TSqlParser) Select_list_elem

func (p *TSqlParser) Select_list_elem() (localctx ISelect_list_elemContext)

func (*TSqlParser) Select_statement

func (p *TSqlParser) Select_statement() (localctx ISelect_statementContext)

func (*TSqlParser) Sempred

func (p *TSqlParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

func (*TSqlParser) Send_conversation

func (p *TSqlParser) Send_conversation() (localctx ISend_conversationContext)

func (*TSqlParser) Service_broker_option

func (p *TSqlParser) Service_broker_option() (localctx IService_broker_optionContext)

func (*TSqlParser) Service_name

func (p *TSqlParser) Service_name() (localctx IService_nameContext)

func (*TSqlParser) Set_special

func (p *TSqlParser) Set_special() (localctx ISet_specialContext)

func (*TSqlParser) Set_statement

func (p *TSqlParser) Set_statement() (localctx ISet_statementContext)

func (*TSqlParser) Setuser_statement

func (p *TSqlParser) Setuser_statement() (localctx ISetuser_statementContext)

func (*TSqlParser) Sign

func (p *TSqlParser) Sign() (localctx ISignContext)

func (*TSqlParser) Simple_id

func (p *TSqlParser) Simple_id() (localctx ISimple_idContext)

func (*TSqlParser) Simple_name

func (p *TSqlParser) Simple_name() (localctx ISimple_nameContext)

func (*TSqlParser) Snapshot_option

func (p *TSqlParser) Snapshot_option() (localctx ISnapshot_optionContext)

func (*TSqlParser) Sql_clause

func (p *TSqlParser) Sql_clause() (localctx ISql_clauseContext)

func (*TSqlParser) Sql_clauses

func (p *TSqlParser) Sql_clauses() (localctx ISql_clausesContext)

func (*TSqlParser) Sql_option

func (p *TSqlParser) Sql_option() (localctx ISql_optionContext)

func (*TSqlParser) Sql_union

func (p *TSqlParser) Sql_union() (localctx ISql_unionContext)

func (*TSqlParser) Subquery

func (p *TSqlParser) Subquery() (localctx ISubqueryContext)

func (*TSqlParser) Switch_search_condition_section

func (p *TSqlParser) Switch_search_condition_section() (localctx ISwitch_search_condition_sectionContext)

func (*TSqlParser) Switch_section

func (p *TSqlParser) Switch_section() (localctx ISwitch_sectionContext)

func (*TSqlParser) Table_alias

func (p *TSqlParser) Table_alias() (localctx ITable_aliasContext)

func (*TSqlParser) Table_constraint

func (p *TSqlParser) Table_constraint() (localctx ITable_constraintContext)

func (*TSqlParser) Table_hint

func (p *TSqlParser) Table_hint() (localctx ITable_hintContext)

func (*TSqlParser) Table_name

func (p *TSqlParser) Table_name() (localctx ITable_nameContext)

func (*TSqlParser) Table_name_with_hint

func (p *TSqlParser) Table_name_with_hint() (localctx ITable_name_with_hintContext)

func (*TSqlParser) Table_options

func (p *TSqlParser) Table_options() (localctx ITable_optionsContext)

func (*TSqlParser) Table_source

func (p *TSqlParser) Table_source() (localctx ITable_sourceContext)

func (*TSqlParser) Table_source_item

func (p *TSqlParser) Table_source_item() (localctx ITable_source_itemContext)

func (*TSqlParser) Table_source_item_joined

func (p *TSqlParser) Table_source_item_joined() (localctx ITable_source_item_joinedContext)

func (*TSqlParser) Table_sources

func (p *TSqlParser) Table_sources() (localctx ITable_sourcesContext)

func (*TSqlParser) Table_type_definition

func (p *TSqlParser) Table_type_definition() (localctx ITable_type_definitionContext)

func (*TSqlParser) Table_value_constructor

func (p *TSqlParser) Table_value_constructor() (localctx ITable_value_constructorContext)

func (*TSqlParser) Target_recovery_time_option

func (p *TSqlParser) Target_recovery_time_option() (localctx ITarget_recovery_time_optionContext)

func (*TSqlParser) Termination

func (p *TSqlParser) Termination() (localctx ITerminationContext)

func (*TSqlParser) Throw_error_number

func (p *TSqlParser) Throw_error_number() (localctx IThrow_error_numberContext)

func (*TSqlParser) Throw_message

func (p *TSqlParser) Throw_message() (localctx IThrow_messageContext)

func (*TSqlParser) Throw_state

func (p *TSqlParser) Throw_state() (localctx IThrow_stateContext)

func (*TSqlParser) Throw_statement

func (p *TSqlParser) Throw_statement() (localctx IThrow_statementContext)

func (*TSqlParser) Time

func (p *TSqlParser) Time() (localctx ITimeContext)

func (*TSqlParser) Top_clause

func (p *TSqlParser) Top_clause() (localctx ITop_clauseContext)

func (*TSqlParser) Top_count

func (p *TSqlParser) Top_count() (localctx ITop_countContext)

func (*TSqlParser) Top_percent

func (p *TSqlParser) Top_percent() (localctx ITop_percentContext)

func (*TSqlParser) Transaction_statement

func (p *TSqlParser) Transaction_statement() (localctx ITransaction_statementContext)

func (*TSqlParser) Truncate_table

func (p *TSqlParser) Truncate_table() (localctx ITruncate_tableContext)

func (*TSqlParser) Try_catch_statement

func (p *TSqlParser) Try_catch_statement() (localctx ITry_catch_statementContext)

func (*TSqlParser) Tsql_file

func (p *TSqlParser) Tsql_file() (localctx ITsql_fileContext)

func (*TSqlParser) Udt_elem

func (p *TSqlParser) Udt_elem() (localctx IUdt_elemContext)

func (*TSqlParser) Udt_method_arguments

func (p *TSqlParser) Udt_method_arguments() (localctx IUdt_method_argumentsContext)

func (*TSqlParser) Unary_operator_expression

func (p *TSqlParser) Unary_operator_expression() (localctx IUnary_operator_expressionContext)

func (*TSqlParser) Unpivot_clause

func (p *TSqlParser) Unpivot_clause() (localctx IUnpivot_clauseContext)

func (*TSqlParser) Update_elem

func (p *TSqlParser) Update_elem() (localctx IUpdate_elemContext)

func (*TSqlParser) Update_statement

func (p *TSqlParser) Update_statement() (localctx IUpdate_statementContext)

func (*TSqlParser) Update_statistics

func (p *TSqlParser) Update_statistics() (localctx IUpdate_statisticsContext)

func (*TSqlParser) Use_statement

func (p *TSqlParser) Use_statement() (localctx IUse_statementContext)

func (*TSqlParser) Value_method

func (p *TSqlParser) Value_method() (localctx IValue_methodContext)

func (*TSqlParser) View_attribute

func (p *TSqlParser) View_attribute() (localctx IView_attributeContext)

func (*TSqlParser) Waitfor_conversation

func (p *TSqlParser) Waitfor_conversation() (localctx IWaitfor_conversationContext)

func (*TSqlParser) Waitfor_statement

func (p *TSqlParser) Waitfor_statement() (localctx IWaitfor_statementContext)

func (*TSqlParser) While_statement

func (p *TSqlParser) While_statement() (localctx IWhile_statementContext)

func (*TSqlParser) Window_frame_bound

func (p *TSqlParser) Window_frame_bound() (localctx IWindow_frame_boundContext)

func (*TSqlParser) Window_frame_extent

func (p *TSqlParser) Window_frame_extent() (localctx IWindow_frame_extentContext)

func (*TSqlParser) Window_frame_following

func (p *TSqlParser) Window_frame_following() (localctx IWindow_frame_followingContext)

func (*TSqlParser) Window_frame_preceding

func (p *TSqlParser) Window_frame_preceding() (localctx IWindow_frame_precedingContext)

func (*TSqlParser) With_expression

func (p *TSqlParser) With_expression() (localctx IWith_expressionContext)

func (*TSqlParser) With_table_hints

func (p *TSqlParser) With_table_hints() (localctx IWith_table_hintsContext)

func (*TSqlParser) Witness_option

func (p *TSqlParser) Witness_option() (localctx IWitness_optionContext)

func (*TSqlParser) Witness_partner_equal

func (p *TSqlParser) Witness_partner_equal() (localctx IWitness_partner_equalContext)

func (*TSqlParser) Witness_server

func (p *TSqlParser) Witness_server() (localctx IWitness_serverContext)

func (*TSqlParser) Xml_common_directives

func (p *TSqlParser) Xml_common_directives() (localctx IXml_common_directivesContext)

func (*TSqlParser) Xml_data_type_methods

func (p *TSqlParser) Xml_data_type_methods() (localctx IXml_data_type_methodsContext)

func (*TSqlParser) Xml_schema_collection

func (p *TSqlParser) Xml_schema_collection() (localctx IXml_schema_collectionContext)

func (*TSqlParser) Xml_type_definition

func (p *TSqlParser) Xml_type_definition() (localctx IXml_type_definitionContext)

type Table_aliasContext

type Table_aliasContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_aliasContext

func NewEmptyTable_aliasContext() *Table_aliasContext

func NewTable_aliasContext

func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext

func (*Table_aliasContext) EnterRule

func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener)

func (*Table_aliasContext) ExitRule

func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener)

func (*Table_aliasContext) GetParser

func (s *Table_aliasContext) GetParser() antlr.Parser

func (*Table_aliasContext) GetRuleContext

func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext

func (*Table_aliasContext) Id

func (*Table_aliasContext) IsTable_aliasContext

func (*Table_aliasContext) IsTable_aliasContext()

func (*Table_aliasContext) ToStringTree

func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Table_aliasContext) With_table_hints

func (s *Table_aliasContext) With_table_hints() IWith_table_hintsContext

type Table_constraintContext

type Table_constraintContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_constraintContext

func NewEmptyTable_constraintContext() *Table_constraintContext

func NewTable_constraintContext

func NewTable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_constraintContext

func (*Table_constraintContext) AllColumn_name_list

func (s *Table_constraintContext) AllColumn_name_list() []IColumn_name_listContext

func (*Table_constraintContext) AllDECIMAL

func (s *Table_constraintContext) AllDECIMAL() []antlr.TerminalNode

func (*Table_constraintContext) AllFunction_call

func (s *Table_constraintContext) AllFunction_call() []IFunction_callContext

func (*Table_constraintContext) AllId

func (s *Table_constraintContext) AllId() []IIdContext

func (*Table_constraintContext) AllLR_BRACKET

func (s *Table_constraintContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Table_constraintContext) AllPLUS

func (*Table_constraintContext) AllRR_BRACKET

func (s *Table_constraintContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Table_constraintContext) AllSTRING

func (s *Table_constraintContext) AllSTRING() []antlr.TerminalNode

func (*Table_constraintContext) CHECK

func (*Table_constraintContext) CONSTRAINT

func (s *Table_constraintContext) CONSTRAINT() antlr.TerminalNode

func (*Table_constraintContext) Clustered

func (*Table_constraintContext) Column_name_list

func (s *Table_constraintContext) Column_name_list(i int) IColumn_name_listContext

func (*Table_constraintContext) Column_name_list_with_order

func (s *Table_constraintContext) Column_name_list_with_order() IColumn_name_list_with_orderContext

func (*Table_constraintContext) DECIMAL

func (*Table_constraintContext) DEFAULT

func (*Table_constraintContext) EnterRule

func (s *Table_constraintContext) EnterRule(listener antlr.ParseTreeListener)

func (*Table_constraintContext) ExitRule

func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener)

func (*Table_constraintContext) FOR

func (*Table_constraintContext) FOREIGN

func (*Table_constraintContext) Function_call

func (*Table_constraintContext) GetConstraint

func (s *Table_constraintContext) GetConstraint() IIdContext

func (*Table_constraintContext) GetFk

func (*Table_constraintContext) GetParser

func (s *Table_constraintContext) GetParser() antlr.Parser

func (*Table_constraintContext) GetPk

func (*Table_constraintContext) GetRuleContext

func (s *Table_constraintContext) GetRuleContext() antlr.RuleContext

func (*Table_constraintContext) Id

func (*Table_constraintContext) Index_options

func (*Table_constraintContext) IsTable_constraintContext

func (*Table_constraintContext) IsTable_constraintContext()

func (*Table_constraintContext) KEY

func (*Table_constraintContext) LR_BRACKET

func (s *Table_constraintContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Table_constraintContext) NOT

func (*Table_constraintContext) ON

func (*Table_constraintContext) On_delete

func (*Table_constraintContext) On_update

func (*Table_constraintContext) PLUS

func (*Table_constraintContext) PRIMARY

func (*Table_constraintContext) REFERENCES

func (s *Table_constraintContext) REFERENCES() antlr.TerminalNode

func (*Table_constraintContext) REPLICATION

func (s *Table_constraintContext) REPLICATION() antlr.TerminalNode

func (*Table_constraintContext) RR_BRACKET

func (s *Table_constraintContext) RR_BRACKET(i int) antlr.TerminalNode

func (*Table_constraintContext) STRING

func (*Table_constraintContext) Search_condition

func (s *Table_constraintContext) Search_condition() ISearch_conditionContext

func (*Table_constraintContext) SetConstraint

func (s *Table_constraintContext) SetConstraint(v IIdContext)

func (*Table_constraintContext) SetFk

func (*Table_constraintContext) SetPk

func (*Table_constraintContext) Table_name

func (*Table_constraintContext) ToStringTree

func (s *Table_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Table_constraintContext) UNIQUE

type Table_hintContext

type Table_hintContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_hintContext

func NewEmptyTable_hintContext() *Table_hintContext

func NewTable_hintContext

func NewTable_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_hintContext

func (*Table_hintContext) AllCOMMA

func (s *Table_hintContext) AllCOMMA() []antlr.TerminalNode

func (*Table_hintContext) AllID

func (s *Table_hintContext) AllID() []antlr.TerminalNode

func (*Table_hintContext) AllIndex_value

func (s *Table_hintContext) AllIndex_value() []IIndex_valueContext

func (*Table_hintContext) AllLR_BRACKET

func (s *Table_hintContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Table_hintContext) AllRR_BRACKET

func (s *Table_hintContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Table_hintContext) COMMA

func (*Table_hintContext) DECIMAL

func (s *Table_hintContext) DECIMAL() antlr.TerminalNode

func (*Table_hintContext) EQUAL

func (*Table_hintContext) EnterRule

func (s *Table_hintContext) EnterRule(listener antlr.ParseTreeListener)

func (*Table_hintContext) ExitRule

func (s *Table_hintContext) ExitRule(listener antlr.ParseTreeListener)

func (*Table_hintContext) FORCESEEK

func (s *Table_hintContext) FORCESEEK() antlr.TerminalNode

func (*Table_hintContext) GetParser

func (s *Table_hintContext) GetParser() antlr.Parser

func (*Table_hintContext) GetRuleContext

func (s *Table_hintContext) GetRuleContext() antlr.RuleContext

func (*Table_hintContext) ID

func (*Table_hintContext) INDEX

func (*Table_hintContext) Index_value

func (s *Table_hintContext) Index_value(i int) IIndex_valueContext

func (*Table_hintContext) IsTable_hintContext

func (*Table_hintContext) IsTable_hintContext()

func (*Table_hintContext) LR_BRACKET

func (s *Table_hintContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Table_hintContext) NOEXPAND

func (s *Table_hintContext) NOEXPAND() antlr.TerminalNode

func (*Table_hintContext) RR_BRACKET

func (s *Table_hintContext) RR_BRACKET(i int) antlr.TerminalNode

func (*Table_hintContext) SERIALIZABLE

func (s *Table_hintContext) SERIALIZABLE() antlr.TerminalNode

func (*Table_hintContext) SNAPSHOT

func (s *Table_hintContext) SNAPSHOT() antlr.TerminalNode

func (*Table_hintContext) SPATIAL_WINDOW_MAX_CELLS

func (s *Table_hintContext) SPATIAL_WINDOW_MAX_CELLS() antlr.TerminalNode

func (*Table_hintContext) ToStringTree

func (s *Table_hintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Table_nameContext

type Table_nameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_nameContext

func NewEmptyTable_nameContext() *Table_nameContext

func NewTable_nameContext

func NewTable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_nameContext

func (*Table_nameContext) AllDOT

func (s *Table_nameContext) AllDOT() []antlr.TerminalNode

func (*Table_nameContext) AllId

func (s *Table_nameContext) AllId() []IIdContext

func (*Table_nameContext) BLOCKING_HIERARCHY

func (s *Table_nameContext) BLOCKING_HIERARCHY() antlr.TerminalNode

func (*Table_nameContext) DOT

func (*Table_nameContext) EnterRule

func (s *Table_nameContext) EnterRule(listener antlr.ParseTreeListener)

func (*Table_nameContext) ExitRule

func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener)

func (*Table_nameContext) GetDatabase

func (s *Table_nameContext) GetDatabase() IIdContext

func (*Table_nameContext) GetParser

func (s *Table_nameContext) GetParser() antlr.Parser

func (*Table_nameContext) GetRuleContext

func (s *Table_nameContext) GetRuleContext() antlr.RuleContext

func (*Table_nameContext) GetSchema

func (s *Table_nameContext) GetSchema() IIdContext

func (*Table_nameContext) GetTable

func (s *Table_nameContext) GetTable() IIdContext

func (*Table_nameContext) Id

func (s *Table_nameContext) Id(i int) IIdContext

func (*Table_nameContext) IsTable_nameContext

func (*Table_nameContext) IsTable_nameContext()

func (*Table_nameContext) SetDatabase

func (s *Table_nameContext) SetDatabase(v IIdContext)

func (*Table_nameContext) SetSchema

func (s *Table_nameContext) SetSchema(v IIdContext)

func (*Table_nameContext) SetTable

func (s *Table_nameContext) SetTable(v IIdContext)

func (*Table_nameContext) ToStringTree

func (s *Table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Table_name_with_hintContext

type Table_name_with_hintContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_name_with_hintContext

func NewEmptyTable_name_with_hintContext() *Table_name_with_hintContext

func NewTable_name_with_hintContext

func NewTable_name_with_hintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_name_with_hintContext

func (*Table_name_with_hintContext) EnterRule

func (s *Table_name_with_hintContext) EnterRule(listener antlr.ParseTreeListener)

func (*Table_name_with_hintContext) ExitRule

func (s *Table_name_with_hintContext) ExitRule(listener antlr.ParseTreeListener)

func (*Table_name_with_hintContext) GetParser

func (s *Table_name_with_hintContext) GetParser() antlr.Parser

func (*Table_name_with_hintContext) GetRuleContext

func (s *Table_name_with_hintContext) GetRuleContext() antlr.RuleContext

func (*Table_name_with_hintContext) IsTable_name_with_hintContext

func (*Table_name_with_hintContext) IsTable_name_with_hintContext()

func (*Table_name_with_hintContext) Table_name

func (*Table_name_with_hintContext) ToStringTree

func (s *Table_name_with_hintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Table_name_with_hintContext) With_table_hints

type Table_optionsContext

type Table_optionsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_optionsContext

func NewEmptyTable_optionsContext() *Table_optionsContext

func NewTable_optionsContext

func NewTable_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_optionsContext

func (*Table_optionsContext) AllCOMMA

func (s *Table_optionsContext) AllCOMMA() []antlr.TerminalNode

func (*Table_optionsContext) AllIndex_option

func (s *Table_optionsContext) AllIndex_option() []IIndex_optionContext

func (*Table_optionsContext) COMMA

func (*Table_optionsContext) EnterRule

func (s *Table_optionsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Table_optionsContext) ExitRule

func (s *Table_optionsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Table_optionsContext) GetParser

func (s *Table_optionsContext) GetParser() antlr.Parser

func (*Table_optionsContext) GetRuleContext

func (s *Table_optionsContext) GetRuleContext() antlr.RuleContext

func (*Table_optionsContext) Index_option

func (s *Table_optionsContext) Index_option(i int) IIndex_optionContext

func (*Table_optionsContext) IsTable_optionsContext

func (*Table_optionsContext) IsTable_optionsContext()

func (*Table_optionsContext) LR_BRACKET

func (s *Table_optionsContext) LR_BRACKET() antlr.TerminalNode

func (*Table_optionsContext) RR_BRACKET

func (s *Table_optionsContext) RR_BRACKET() antlr.TerminalNode

func (*Table_optionsContext) ToStringTree

func (s *Table_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Table_optionsContext) WITH

type Table_sourceContext

type Table_sourceContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_sourceContext

func NewEmptyTable_sourceContext() *Table_sourceContext

func NewTable_sourceContext

func NewTable_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_sourceContext

func (*Table_sourceContext) EnterRule

func (s *Table_sourceContext) EnterRule(listener antlr.ParseTreeListener)

func (*Table_sourceContext) ExitRule

func (s *Table_sourceContext) ExitRule(listener antlr.ParseTreeListener)

func (*Table_sourceContext) GetParser

func (s *Table_sourceContext) GetParser() antlr.Parser

func (*Table_sourceContext) GetRuleContext

func (s *Table_sourceContext) GetRuleContext() antlr.RuleContext

func (*Table_sourceContext) IsTable_sourceContext

func (*Table_sourceContext) IsTable_sourceContext()

func (*Table_sourceContext) LR_BRACKET

func (s *Table_sourceContext) LR_BRACKET() antlr.TerminalNode

func (*Table_sourceContext) RR_BRACKET

func (s *Table_sourceContext) RR_BRACKET() antlr.TerminalNode

func (*Table_sourceContext) Table_source_item_joined

func (s *Table_sourceContext) Table_source_item_joined() ITable_source_item_joinedContext

func (*Table_sourceContext) ToStringTree

func (s *Table_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Table_source_itemContext

type Table_source_itemContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_source_itemContext

func NewEmptyTable_source_itemContext() *Table_source_itemContext

func NewTable_source_itemContext

func NewTable_source_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_source_itemContext

func (*Table_source_itemContext) AllCOLON

func (*Table_source_itemContext) As_table_alias

func (*Table_source_itemContext) COLON

func (*Table_source_itemContext) Change_table

func (*Table_source_itemContext) Column_alias_list

func (s *Table_source_itemContext) Column_alias_list() IColumn_alias_listContext

func (*Table_source_itemContext) DOT

func (*Table_source_itemContext) Derived_table

func (*Table_source_itemContext) EnterRule

func (s *Table_source_itemContext) EnterRule(listener antlr.ParseTreeListener)

func (*Table_source_itemContext) ExitRule

func (s *Table_source_itemContext) ExitRule(listener antlr.ParseTreeListener)

func (*Table_source_itemContext) Full_table_name

func (*Table_source_itemContext) Function_call

func (*Table_source_itemContext) GetParser

func (s *Table_source_itemContext) GetParser() antlr.Parser

func (*Table_source_itemContext) GetRuleContext

func (s *Table_source_itemContext) GetRuleContext() antlr.RuleContext

func (*Table_source_itemContext) IsTable_source_itemContext

func (*Table_source_itemContext) IsTable_source_itemContext()

func (*Table_source_itemContext) LOCAL_ID

func (*Table_source_itemContext) Open_xml

func (*Table_source_itemContext) Rowset_function

func (*Table_source_itemContext) Table_name_with_hint

func (s *Table_source_itemContext) Table_name_with_hint() ITable_name_with_hintContext

func (*Table_source_itemContext) ToStringTree

func (s *Table_source_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Table_source_item_joinedContext

type Table_source_item_joinedContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_source_item_joinedContext

func NewEmptyTable_source_item_joinedContext() *Table_source_item_joinedContext

func NewTable_source_item_joinedContext

func NewTable_source_item_joinedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_source_item_joinedContext

func (*Table_source_item_joinedContext) AllJoin_part

func (*Table_source_item_joinedContext) EnterRule

func (*Table_source_item_joinedContext) ExitRule

func (*Table_source_item_joinedContext) GetParser

func (*Table_source_item_joinedContext) GetRuleContext

func (*Table_source_item_joinedContext) IsTable_source_item_joinedContext

func (*Table_source_item_joinedContext) IsTable_source_item_joinedContext()

func (*Table_source_item_joinedContext) Join_part

func (*Table_source_item_joinedContext) Table_source_item

func (*Table_source_item_joinedContext) ToStringTree

func (s *Table_source_item_joinedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Table_sourcesContext

type Table_sourcesContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_sourcesContext

func NewEmptyTable_sourcesContext() *Table_sourcesContext

func NewTable_sourcesContext

func NewTable_sourcesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_sourcesContext

func (*Table_sourcesContext) AllCOMMA

func (s *Table_sourcesContext) AllCOMMA() []antlr.TerminalNode

func (*Table_sourcesContext) AllTable_source

func (s *Table_sourcesContext) AllTable_source() []ITable_sourceContext

func (*Table_sourcesContext) COMMA

func (*Table_sourcesContext) EnterRule

func (s *Table_sourcesContext) EnterRule(listener antlr.ParseTreeListener)

func (*Table_sourcesContext) ExitRule

func (s *Table_sourcesContext) ExitRule(listener antlr.ParseTreeListener)

func (*Table_sourcesContext) GetParser

func (s *Table_sourcesContext) GetParser() antlr.Parser

func (*Table_sourcesContext) GetRuleContext

func (s *Table_sourcesContext) GetRuleContext() antlr.RuleContext

func (*Table_sourcesContext) IsTable_sourcesContext

func (*Table_sourcesContext) IsTable_sourcesContext()

func (*Table_sourcesContext) Table_source

func (s *Table_sourcesContext) Table_source(i int) ITable_sourceContext

func (*Table_sourcesContext) ToStringTree

func (s *Table_sourcesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Table_type_definitionContext

type Table_type_definitionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_type_definitionContext

func NewEmptyTable_type_definitionContext() *Table_type_definitionContext

func NewTable_type_definitionContext

func NewTable_type_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_type_definitionContext

func (*Table_type_definitionContext) Column_def_table_constraints

func (s *Table_type_definitionContext) Column_def_table_constraints() IColumn_def_table_constraintsContext

func (*Table_type_definitionContext) EnterRule

func (s *Table_type_definitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Table_type_definitionContext) ExitRule

func (*Table_type_definitionContext) GetParser

func (s *Table_type_definitionContext) GetParser() antlr.Parser

func (*Table_type_definitionContext) GetRuleContext

func (s *Table_type_definitionContext) GetRuleContext() antlr.RuleContext

func (*Table_type_definitionContext) IsTable_type_definitionContext

func (*Table_type_definitionContext) IsTable_type_definitionContext()

func (*Table_type_definitionContext) LR_BRACKET

func (*Table_type_definitionContext) RR_BRACKET

func (*Table_type_definitionContext) TABLE

func (*Table_type_definitionContext) ToStringTree

func (s *Table_type_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Table_value_constructorContext

type Table_value_constructorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTable_value_constructorContext

func NewEmptyTable_value_constructorContext() *Table_value_constructorContext

func NewTable_value_constructorContext

func NewTable_value_constructorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_value_constructorContext

func (*Table_value_constructorContext) AllCOMMA

func (*Table_value_constructorContext) AllExpression_list

func (s *Table_value_constructorContext) AllExpression_list() []IExpression_listContext

func (*Table_value_constructorContext) AllLR_BRACKET

func (s *Table_value_constructorContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Table_value_constructorContext) AllRR_BRACKET

func (s *Table_value_constructorContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Table_value_constructorContext) COMMA

func (*Table_value_constructorContext) EnterRule

func (*Table_value_constructorContext) ExitRule

func (*Table_value_constructorContext) Expression_list

func (*Table_value_constructorContext) GetParser

func (*Table_value_constructorContext) GetRuleContext

func (s *Table_value_constructorContext) GetRuleContext() antlr.RuleContext

func (*Table_value_constructorContext) IsTable_value_constructorContext

func (*Table_value_constructorContext) IsTable_value_constructorContext()

func (*Table_value_constructorContext) LR_BRACKET

func (*Table_value_constructorContext) RR_BRACKET

func (*Table_value_constructorContext) ToStringTree

func (s *Table_value_constructorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Table_value_constructorContext) VALUES

type Target_recovery_time_optionContext

type Target_recovery_time_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTarget_recovery_time_optionContext

func NewEmptyTarget_recovery_time_optionContext() *Target_recovery_time_optionContext

func NewTarget_recovery_time_optionContext

func NewTarget_recovery_time_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Target_recovery_time_optionContext

func (*Target_recovery_time_optionContext) DECIMAL

func (*Target_recovery_time_optionContext) EQUAL

func (*Target_recovery_time_optionContext) EnterRule

func (*Target_recovery_time_optionContext) ExitRule

func (*Target_recovery_time_optionContext) GetParser

func (*Target_recovery_time_optionContext) GetRuleContext

func (*Target_recovery_time_optionContext) IsTarget_recovery_time_optionContext

func (*Target_recovery_time_optionContext) IsTarget_recovery_time_optionContext()

func (*Target_recovery_time_optionContext) MINUTES

func (*Target_recovery_time_optionContext) SECONDS

func (*Target_recovery_time_optionContext) TARGET_RECOVERY_TIME

func (s *Target_recovery_time_optionContext) TARGET_RECOVERY_TIME() antlr.TerminalNode

func (*Target_recovery_time_optionContext) ToStringTree

func (s *Target_recovery_time_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TerminationContext

type TerminationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTerminationContext

func NewEmptyTerminationContext() *TerminationContext

func NewTerminationContext

func NewTerminationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TerminationContext

func (*TerminationContext) AFTER

func (*TerminationContext) DECIMAL

func (s *TerminationContext) DECIMAL() antlr.TerminalNode

func (*TerminationContext) EnterRule

func (s *TerminationContext) EnterRule(listener antlr.ParseTreeListener)

func (*TerminationContext) ExitRule

func (s *TerminationContext) ExitRule(listener antlr.ParseTreeListener)

func (*TerminationContext) GetParser

func (s *TerminationContext) GetParser() antlr.Parser

func (*TerminationContext) GetRuleContext

func (s *TerminationContext) GetRuleContext() antlr.RuleContext

func (*TerminationContext) GetSeconds

func (s *TerminationContext) GetSeconds() antlr.Token

func (*TerminationContext) IMMEDIATE

func (s *TerminationContext) IMMEDIATE() antlr.TerminalNode

func (*TerminationContext) IsTerminationContext

func (*TerminationContext) IsTerminationContext()

func (*TerminationContext) NO_WAIT

func (s *TerminationContext) NO_WAIT() antlr.TerminalNode

func (*TerminationContext) ROLLBACK

func (s *TerminationContext) ROLLBACK() antlr.TerminalNode

func (*TerminationContext) SetSeconds

func (s *TerminationContext) SetSeconds(v antlr.Token)

func (*TerminationContext) ToStringTree

func (s *TerminationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Throw_error_numberContext

type Throw_error_numberContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyThrow_error_numberContext

func NewEmptyThrow_error_numberContext() *Throw_error_numberContext

func NewThrow_error_numberContext

func NewThrow_error_numberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Throw_error_numberContext

func (*Throw_error_numberContext) DECIMAL

func (*Throw_error_numberContext) EnterRule

func (s *Throw_error_numberContext) EnterRule(listener antlr.ParseTreeListener)

func (*Throw_error_numberContext) ExitRule

func (s *Throw_error_numberContext) ExitRule(listener antlr.ParseTreeListener)

func (*Throw_error_numberContext) GetParser

func (s *Throw_error_numberContext) GetParser() antlr.Parser

func (*Throw_error_numberContext) GetRuleContext

func (s *Throw_error_numberContext) GetRuleContext() antlr.RuleContext

func (*Throw_error_numberContext) IsThrow_error_numberContext

func (*Throw_error_numberContext) IsThrow_error_numberContext()

func (*Throw_error_numberContext) LOCAL_ID

func (*Throw_error_numberContext) ToStringTree

func (s *Throw_error_numberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Throw_messageContext

type Throw_messageContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyThrow_messageContext

func NewEmptyThrow_messageContext() *Throw_messageContext

func NewThrow_messageContext

func NewThrow_messageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Throw_messageContext

func (*Throw_messageContext) EnterRule

func (s *Throw_messageContext) EnterRule(listener antlr.ParseTreeListener)

func (*Throw_messageContext) ExitRule

func (s *Throw_messageContext) ExitRule(listener antlr.ParseTreeListener)

func (*Throw_messageContext) GetParser

func (s *Throw_messageContext) GetParser() antlr.Parser

func (*Throw_messageContext) GetRuleContext

func (s *Throw_messageContext) GetRuleContext() antlr.RuleContext

func (*Throw_messageContext) IsThrow_messageContext

func (*Throw_messageContext) IsThrow_messageContext()

func (*Throw_messageContext) LOCAL_ID

func (s *Throw_messageContext) LOCAL_ID() antlr.TerminalNode

func (*Throw_messageContext) STRING

func (*Throw_messageContext) ToStringTree

func (s *Throw_messageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Throw_stateContext

type Throw_stateContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyThrow_stateContext

func NewEmptyThrow_stateContext() *Throw_stateContext

func NewThrow_stateContext

func NewThrow_stateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Throw_stateContext

func (*Throw_stateContext) DECIMAL

func (s *Throw_stateContext) DECIMAL() antlr.TerminalNode

func (*Throw_stateContext) EnterRule

func (s *Throw_stateContext) EnterRule(listener antlr.ParseTreeListener)

func (*Throw_stateContext) ExitRule

func (s *Throw_stateContext) ExitRule(listener antlr.ParseTreeListener)

func (*Throw_stateContext) GetParser

func (s *Throw_stateContext) GetParser() antlr.Parser

func (*Throw_stateContext) GetRuleContext

func (s *Throw_stateContext) GetRuleContext() antlr.RuleContext

func (*Throw_stateContext) IsThrow_stateContext

func (*Throw_stateContext) IsThrow_stateContext()

func (*Throw_stateContext) LOCAL_ID

func (s *Throw_stateContext) LOCAL_ID() antlr.TerminalNode

func (*Throw_stateContext) ToStringTree

func (s *Throw_stateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Throw_statementContext

type Throw_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyThrow_statementContext

func NewEmptyThrow_statementContext() *Throw_statementContext

func NewThrow_statementContext

func NewThrow_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Throw_statementContext

func (*Throw_statementContext) AllCOMMA

func (s *Throw_statementContext) AllCOMMA() []antlr.TerminalNode

func (*Throw_statementContext) COMMA

func (*Throw_statementContext) EnterRule

func (s *Throw_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Throw_statementContext) ExitRule

func (s *Throw_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Throw_statementContext) GetParser

func (s *Throw_statementContext) GetParser() antlr.Parser

func (*Throw_statementContext) GetRuleContext

func (s *Throw_statementContext) GetRuleContext() antlr.RuleContext

func (*Throw_statementContext) IsThrow_statementContext

func (*Throw_statementContext) IsThrow_statementContext()

func (*Throw_statementContext) SEMI

func (*Throw_statementContext) THROW

func (*Throw_statementContext) Throw_error_number

func (s *Throw_statementContext) Throw_error_number() IThrow_error_numberContext

func (*Throw_statementContext) Throw_message

func (s *Throw_statementContext) Throw_message() IThrow_messageContext

func (*Throw_statementContext) Throw_state

func (*Throw_statementContext) ToStringTree

func (s *Throw_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type TimeContext

type TimeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTimeContext

func NewEmptyTimeContext() *TimeContext

func NewTimeContext

func NewTimeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TimeContext

func (*TimeContext) Constant

func (s *TimeContext) Constant() IConstantContext

func (*TimeContext) EnterRule

func (s *TimeContext) EnterRule(listener antlr.ParseTreeListener)

func (*TimeContext) ExitRule

func (s *TimeContext) ExitRule(listener antlr.ParseTreeListener)

func (*TimeContext) GetParser

func (s *TimeContext) GetParser() antlr.Parser

func (*TimeContext) GetRuleContext

func (s *TimeContext) GetRuleContext() antlr.RuleContext

func (*TimeContext) IsTimeContext

func (*TimeContext) IsTimeContext()

func (*TimeContext) LOCAL_ID

func (s *TimeContext) LOCAL_ID() antlr.TerminalNode

func (*TimeContext) ToStringTree

func (s *TimeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Top_clauseContext

type Top_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTop_clauseContext

func NewEmptyTop_clauseContext() *Top_clauseContext

func NewTop_clauseContext

func NewTop_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Top_clauseContext

func (*Top_clauseContext) EnterRule

func (s *Top_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Top_clauseContext) ExitRule

func (s *Top_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Top_clauseContext) GetParser

func (s *Top_clauseContext) GetParser() antlr.Parser

func (*Top_clauseContext) GetRuleContext

func (s *Top_clauseContext) GetRuleContext() antlr.RuleContext

func (*Top_clauseContext) IsTop_clauseContext

func (*Top_clauseContext) IsTop_clauseContext()

func (*Top_clauseContext) TIES

func (*Top_clauseContext) TOP

func (*Top_clauseContext) ToStringTree

func (s *Top_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Top_clauseContext) Top_count

func (s *Top_clauseContext) Top_count() ITop_countContext

func (*Top_clauseContext) Top_percent

func (s *Top_clauseContext) Top_percent() ITop_percentContext

func (*Top_clauseContext) WITH

type Top_countContext

type Top_countContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTop_countContext

func NewEmptyTop_countContext() *Top_countContext

func NewTop_countContext

func NewTop_countContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Top_countContext

func (*Top_countContext) DECIMAL

func (s *Top_countContext) DECIMAL() antlr.TerminalNode

func (*Top_countContext) EnterRule

func (s *Top_countContext) EnterRule(listener antlr.ParseTreeListener)

func (*Top_countContext) ExitRule

func (s *Top_countContext) ExitRule(listener antlr.ParseTreeListener)

func (*Top_countContext) Expression

func (s *Top_countContext) Expression() IExpressionContext

func (*Top_countContext) GetParser

func (s *Top_countContext) GetParser() antlr.Parser

func (*Top_countContext) GetRuleContext

func (s *Top_countContext) GetRuleContext() antlr.RuleContext

func (*Top_countContext) IsTop_countContext

func (*Top_countContext) IsTop_countContext()

func (*Top_countContext) LR_BRACKET

func (s *Top_countContext) LR_BRACKET() antlr.TerminalNode

func (*Top_countContext) RR_BRACKET

func (s *Top_countContext) RR_BRACKET() antlr.TerminalNode

func (*Top_countContext) ToStringTree

func (s *Top_countContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Top_percentContext

type Top_percentContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTop_percentContext

func NewEmptyTop_percentContext() *Top_percentContext

func NewTop_percentContext

func NewTop_percentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Top_percentContext

func (*Top_percentContext) EnterRule

func (s *Top_percentContext) EnterRule(listener antlr.ParseTreeListener)

func (*Top_percentContext) ExitRule

func (s *Top_percentContext) ExitRule(listener antlr.ParseTreeListener)

func (*Top_percentContext) Expression

func (s *Top_percentContext) Expression() IExpressionContext

func (*Top_percentContext) FLOAT

func (*Top_percentContext) GetParser

func (s *Top_percentContext) GetParser() antlr.Parser

func (*Top_percentContext) GetRuleContext

func (s *Top_percentContext) GetRuleContext() antlr.RuleContext

func (*Top_percentContext) IsTop_percentContext

func (*Top_percentContext) IsTop_percentContext()

func (*Top_percentContext) LR_BRACKET

func (s *Top_percentContext) LR_BRACKET() antlr.TerminalNode

func (*Top_percentContext) PERCENT

func (s *Top_percentContext) PERCENT() antlr.TerminalNode

func (*Top_percentContext) REAL

func (*Top_percentContext) RR_BRACKET

func (s *Top_percentContext) RR_BRACKET() antlr.TerminalNode

func (*Top_percentContext) ToStringTree

func (s *Top_percentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Transaction_statementContext

type Transaction_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTransaction_statementContext

func NewEmptyTransaction_statementContext() *Transaction_statementContext

func NewTransaction_statementContext

func NewTransaction_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_statementContext

func (*Transaction_statementContext) BEGIN

func (*Transaction_statementContext) COMMIT

func (*Transaction_statementContext) DELAYED_DURABILITY

func (s *Transaction_statementContext) DELAYED_DURABILITY() antlr.TerminalNode

func (*Transaction_statementContext) DISTRIBUTED

func (*Transaction_statementContext) EQUAL

func (*Transaction_statementContext) EnterRule

func (s *Transaction_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Transaction_statementContext) ExitRule

func (*Transaction_statementContext) GetParser

func (s *Transaction_statementContext) GetParser() antlr.Parser

func (*Transaction_statementContext) GetRuleContext

func (s *Transaction_statementContext) GetRuleContext() antlr.RuleContext

func (*Transaction_statementContext) Id

func (*Transaction_statementContext) IsTransaction_statementContext

func (*Transaction_statementContext) IsTransaction_statementContext()

func (*Transaction_statementContext) LOCAL_ID

func (*Transaction_statementContext) LR_BRACKET

func (*Transaction_statementContext) MARK

func (*Transaction_statementContext) OFF

func (*Transaction_statementContext) ON

func (*Transaction_statementContext) ROLLBACK

func (*Transaction_statementContext) RR_BRACKET

func (*Transaction_statementContext) SAVE

func (*Transaction_statementContext) SEMI

func (*Transaction_statementContext) STRING

func (*Transaction_statementContext) TRAN

func (*Transaction_statementContext) TRANSACTION

func (*Transaction_statementContext) ToStringTree

func (s *Transaction_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Transaction_statementContext) WITH

func (*Transaction_statementContext) WORK

type Truncate_tableContext

type Truncate_tableContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTruncate_tableContext

func NewEmptyTruncate_tableContext() *Truncate_tableContext

func NewTruncate_tableContext

func NewTruncate_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Truncate_tableContext

func (*Truncate_tableContext) AllCOMMA

func (s *Truncate_tableContext) AllCOMMA() []antlr.TerminalNode

func (*Truncate_tableContext) AllDECIMAL

func (s *Truncate_tableContext) AllDECIMAL() []antlr.TerminalNode

func (*Truncate_tableContext) AllLR_BRACKET

func (s *Truncate_tableContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Truncate_tableContext) AllRR_BRACKET

func (s *Truncate_tableContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Truncate_tableContext) AllTO

func (*Truncate_tableContext) COMMA

func (*Truncate_tableContext) DECIMAL

func (*Truncate_tableContext) EnterRule

func (s *Truncate_tableContext) EnterRule(listener antlr.ParseTreeListener)

func (*Truncate_tableContext) ExitRule

func (s *Truncate_tableContext) ExitRule(listener antlr.ParseTreeListener)

func (*Truncate_tableContext) GetParser

func (s *Truncate_tableContext) GetParser() antlr.Parser

func (*Truncate_tableContext) GetRuleContext

func (s *Truncate_tableContext) GetRuleContext() antlr.RuleContext

func (*Truncate_tableContext) IsTruncate_tableContext

func (*Truncate_tableContext) IsTruncate_tableContext()

func (*Truncate_tableContext) LR_BRACKET

func (s *Truncate_tableContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Truncate_tableContext) PARTITIONS

func (s *Truncate_tableContext) PARTITIONS() antlr.TerminalNode

func (*Truncate_tableContext) RR_BRACKET

func (s *Truncate_tableContext) RR_BRACKET(i int) antlr.TerminalNode

func (*Truncate_tableContext) TABLE

func (*Truncate_tableContext) TO

func (*Truncate_tableContext) TRUNCATE

func (*Truncate_tableContext) Table_name

func (s *Truncate_tableContext) Table_name() ITable_nameContext

func (*Truncate_tableContext) ToStringTree

func (s *Truncate_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Truncate_tableContext) WITH

type Try_catch_statementContext

type Try_catch_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTry_catch_statementContext

func NewEmptyTry_catch_statementContext() *Try_catch_statementContext

func NewTry_catch_statementContext

func NewTry_catch_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Try_catch_statementContext

func (*Try_catch_statementContext) AllBEGIN

func (*Try_catch_statementContext) AllCATCH

func (*Try_catch_statementContext) AllEND

func (*Try_catch_statementContext) AllSEMI

func (*Try_catch_statementContext) AllSql_clauses

func (s *Try_catch_statementContext) AllSql_clauses() []ISql_clausesContext

func (*Try_catch_statementContext) AllTRY

func (*Try_catch_statementContext) BEGIN

func (*Try_catch_statementContext) CATCH

func (*Try_catch_statementContext) END

func (*Try_catch_statementContext) EnterRule

func (s *Try_catch_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Try_catch_statementContext) ExitRule

func (s *Try_catch_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Try_catch_statementContext) GetCatch_clauses

func (s *Try_catch_statementContext) GetCatch_clauses() ISql_clausesContext

func (*Try_catch_statementContext) GetParser

func (s *Try_catch_statementContext) GetParser() antlr.Parser

func (*Try_catch_statementContext) GetRuleContext

func (s *Try_catch_statementContext) GetRuleContext() antlr.RuleContext

func (*Try_catch_statementContext) GetTry_clauses

func (s *Try_catch_statementContext) GetTry_clauses() ISql_clausesContext

func (*Try_catch_statementContext) IsTry_catch_statementContext

func (*Try_catch_statementContext) IsTry_catch_statementContext()

func (*Try_catch_statementContext) SEMI

func (*Try_catch_statementContext) SetCatch_clauses

func (s *Try_catch_statementContext) SetCatch_clauses(v ISql_clausesContext)

func (*Try_catch_statementContext) SetTry_clauses

func (s *Try_catch_statementContext) SetTry_clauses(v ISql_clausesContext)

func (*Try_catch_statementContext) Sql_clauses

func (*Try_catch_statementContext) TRY

func (*Try_catch_statementContext) ToStringTree

func (s *Try_catch_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Tsql_fileContext

type Tsql_fileContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyTsql_fileContext

func NewEmptyTsql_fileContext() *Tsql_fileContext

func NewTsql_fileContext

func NewTsql_fileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tsql_fileContext

func (*Tsql_fileContext) AllBatch

func (s *Tsql_fileContext) AllBatch() []IBatchContext

func (*Tsql_fileContext) Batch

func (s *Tsql_fileContext) Batch(i int) IBatchContext

func (*Tsql_fileContext) EOF

func (*Tsql_fileContext) EnterRule

func (s *Tsql_fileContext) EnterRule(listener antlr.ParseTreeListener)

func (*Tsql_fileContext) ExitRule

func (s *Tsql_fileContext) ExitRule(listener antlr.ParseTreeListener)

func (*Tsql_fileContext) GetParser

func (s *Tsql_fileContext) GetParser() antlr.Parser

func (*Tsql_fileContext) GetRuleContext

func (s *Tsql_fileContext) GetRuleContext() antlr.RuleContext

func (*Tsql_fileContext) IsTsql_fileContext

func (*Tsql_fileContext) IsTsql_fileContext()

func (*Tsql_fileContext) ToStringTree

func (s *Tsql_fileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Udt_elemContext

type Udt_elemContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUdt_elemContext

func NewEmptyUdt_elemContext() *Udt_elemContext

func NewUdt_elemContext

func NewUdt_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Udt_elemContext

func (*Udt_elemContext) AllCOLON

func (s *Udt_elemContext) AllCOLON() []antlr.TerminalNode

func (*Udt_elemContext) AllId

func (s *Udt_elemContext) AllId() []IIdContext

func (*Udt_elemContext) As_column_alias

func (s *Udt_elemContext) As_column_alias() IAs_column_aliasContext

func (*Udt_elemContext) COLON

func (s *Udt_elemContext) COLON(i int) antlr.TerminalNode

func (*Udt_elemContext) DOT

func (*Udt_elemContext) EnterRule

func (s *Udt_elemContext) EnterRule(listener antlr.ParseTreeListener)

func (*Udt_elemContext) ExitRule

func (s *Udt_elemContext) ExitRule(listener antlr.ParseTreeListener)

func (*Udt_elemContext) GetNon_static_attr

func (s *Udt_elemContext) GetNon_static_attr() IIdContext

func (*Udt_elemContext) GetParser

func (s *Udt_elemContext) GetParser() antlr.Parser

func (*Udt_elemContext) GetRuleContext

func (s *Udt_elemContext) GetRuleContext() antlr.RuleContext

func (*Udt_elemContext) GetStatic_attr

func (s *Udt_elemContext) GetStatic_attr() IIdContext

func (*Udt_elemContext) GetUdt_column_name

func (s *Udt_elemContext) GetUdt_column_name() IIdContext

func (*Udt_elemContext) Id

func (s *Udt_elemContext) Id(i int) IIdContext

func (*Udt_elemContext) IsUdt_elemContext

func (*Udt_elemContext) IsUdt_elemContext()

func (*Udt_elemContext) SetNon_static_attr

func (s *Udt_elemContext) SetNon_static_attr(v IIdContext)

func (*Udt_elemContext) SetStatic_attr

func (s *Udt_elemContext) SetStatic_attr(v IIdContext)

func (*Udt_elemContext) SetUdt_column_name

func (s *Udt_elemContext) SetUdt_column_name(v IIdContext)

func (*Udt_elemContext) ToStringTree

func (s *Udt_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Udt_elemContext) Udt_method_arguments

func (s *Udt_elemContext) Udt_method_arguments() IUdt_method_argumentsContext

type Udt_method_argumentsContext

type Udt_method_argumentsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUdt_method_argumentsContext

func NewEmptyUdt_method_argumentsContext() *Udt_method_argumentsContext

func NewUdt_method_argumentsContext

func NewUdt_method_argumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Udt_method_argumentsContext

func (*Udt_method_argumentsContext) AllCOMMA

func (*Udt_method_argumentsContext) AllExecute_var_string

func (s *Udt_method_argumentsContext) AllExecute_var_string() []IExecute_var_stringContext

func (*Udt_method_argumentsContext) COMMA

func (*Udt_method_argumentsContext) EnterRule

func (s *Udt_method_argumentsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Udt_method_argumentsContext) Execute_var_string

func (*Udt_method_argumentsContext) ExitRule

func (s *Udt_method_argumentsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Udt_method_argumentsContext) GetParser

func (s *Udt_method_argumentsContext) GetParser() antlr.Parser

func (*Udt_method_argumentsContext) GetRuleContext

func (s *Udt_method_argumentsContext) GetRuleContext() antlr.RuleContext

func (*Udt_method_argumentsContext) IsUdt_method_argumentsContext

func (*Udt_method_argumentsContext) IsUdt_method_argumentsContext()

func (*Udt_method_argumentsContext) LR_BRACKET

func (*Udt_method_argumentsContext) RR_BRACKET

func (*Udt_method_argumentsContext) ToStringTree

func (s *Udt_method_argumentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Unary_operator_expressionContext

type Unary_operator_expressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUnary_operator_expressionContext

func NewEmptyUnary_operator_expressionContext() *Unary_operator_expressionContext

func NewUnary_operator_expressionContext

func NewUnary_operator_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_operator_expressionContext

func (*Unary_operator_expressionContext) BIT_NOT

func (*Unary_operator_expressionContext) EnterRule

func (*Unary_operator_expressionContext) ExitRule

func (*Unary_operator_expressionContext) Expression

func (*Unary_operator_expressionContext) GetOp

func (*Unary_operator_expressionContext) GetParser

func (*Unary_operator_expressionContext) GetRuleContext

func (*Unary_operator_expressionContext) IsUnary_operator_expressionContext

func (*Unary_operator_expressionContext) IsUnary_operator_expressionContext()

func (*Unary_operator_expressionContext) MINUS

func (*Unary_operator_expressionContext) PLUS

func (*Unary_operator_expressionContext) SetOp

func (*Unary_operator_expressionContext) ToStringTree

func (s *Unary_operator_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Unpivot_clauseContext

type Unpivot_clauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUnpivot_clauseContext

func NewEmptyUnpivot_clauseContext() *Unpivot_clauseContext

func NewUnpivot_clauseContext

func NewUnpivot_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_clauseContext

func (*Unpivot_clauseContext) AllLR_BRACKET

func (s *Unpivot_clauseContext) AllLR_BRACKET() []antlr.TerminalNode

func (*Unpivot_clauseContext) AllRR_BRACKET

func (s *Unpivot_clauseContext) AllRR_BRACKET() []antlr.TerminalNode

func (*Unpivot_clauseContext) EnterRule

func (s *Unpivot_clauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*Unpivot_clauseContext) ExitRule

func (s *Unpivot_clauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*Unpivot_clauseContext) Expression

func (s *Unpivot_clauseContext) Expression() IExpressionContext

func (*Unpivot_clauseContext) FOR

func (*Unpivot_clauseContext) Full_column_name

func (s *Unpivot_clauseContext) Full_column_name() IFull_column_nameContext

func (*Unpivot_clauseContext) Full_column_name_list

func (s *Unpivot_clauseContext) Full_column_name_list() IFull_column_name_listContext

func (*Unpivot_clauseContext) GetParser

func (s *Unpivot_clauseContext) GetParser() antlr.Parser

func (*Unpivot_clauseContext) GetRuleContext

func (s *Unpivot_clauseContext) GetRuleContext() antlr.RuleContext

func (*Unpivot_clauseContext) IN

func (*Unpivot_clauseContext) IsUnpivot_clauseContext

func (*Unpivot_clauseContext) IsUnpivot_clauseContext()

func (*Unpivot_clauseContext) LR_BRACKET

func (s *Unpivot_clauseContext) LR_BRACKET(i int) antlr.TerminalNode

func (*Unpivot_clauseContext) RR_BRACKET

func (s *Unpivot_clauseContext) RR_BRACKET(i int) antlr.TerminalNode

func (*Unpivot_clauseContext) ToStringTree

func (s *Unpivot_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Update_elemContext

type Update_elemContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUpdate_elemContext

func NewEmptyUpdate_elemContext() *Update_elemContext

func NewUpdate_elemContext

func NewUpdate_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_elemContext

func (*Update_elemContext) AllId

func (s *Update_elemContext) AllId() []IIdContext

func (*Update_elemContext) Assignment_operator

func (s *Update_elemContext) Assignment_operator() IAssignment_operatorContext

func (*Update_elemContext) DOT

func (*Update_elemContext) EQUAL

func (*Update_elemContext) EnterRule

func (s *Update_elemContext) EnterRule(listener antlr.ParseTreeListener)

func (*Update_elemContext) ExitRule

func (s *Update_elemContext) ExitRule(listener antlr.ParseTreeListener)

func (*Update_elemContext) Expression

func (s *Update_elemContext) Expression() IExpressionContext

func (*Update_elemContext) Expression_list

func (s *Update_elemContext) Expression_list() IExpression_listContext

func (*Update_elemContext) Full_column_name

func (s *Update_elemContext) Full_column_name() IFull_column_nameContext

func (*Update_elemContext) GetMethod_name

func (s *Update_elemContext) GetMethod_name() IIdContext

func (*Update_elemContext) GetParser

func (s *Update_elemContext) GetParser() antlr.Parser

func (*Update_elemContext) GetRuleContext

func (s *Update_elemContext) GetRuleContext() antlr.RuleContext

func (*Update_elemContext) GetUdt_column_name

func (s *Update_elemContext) GetUdt_column_name() IIdContext

func (*Update_elemContext) Id

func (*Update_elemContext) IsUpdate_elemContext

func (*Update_elemContext) IsUpdate_elemContext()

func (*Update_elemContext) LOCAL_ID

func (s *Update_elemContext) LOCAL_ID() antlr.TerminalNode

func (*Update_elemContext) LR_BRACKET

func (s *Update_elemContext) LR_BRACKET() antlr.TerminalNode

func (*Update_elemContext) RR_BRACKET

func (s *Update_elemContext) RR_BRACKET() antlr.TerminalNode

func (*Update_elemContext) SetMethod_name

func (s *Update_elemContext) SetMethod_name(v IIdContext)

func (*Update_elemContext) SetUdt_column_name

func (s *Update_elemContext) SetUdt_column_name(v IIdContext)

func (*Update_elemContext) ToStringTree

func (s *Update_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Update_statementContext

type Update_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUpdate_statementContext

func NewEmptyUpdate_statementContext() *Update_statementContext

func NewUpdate_statementContext

func NewUpdate_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_statementContext

func (*Update_statementContext) AllCOMMA

func (s *Update_statementContext) AllCOMMA() []antlr.TerminalNode

func (*Update_statementContext) AllUpdate_elem

func (s *Update_statementContext) AllUpdate_elem() []IUpdate_elemContext

func (*Update_statementContext) COMMA

func (*Update_statementContext) CURRENT

func (*Update_statementContext) Cursor_name

func (*Update_statementContext) Ddl_object

func (*Update_statementContext) EnterRule

func (s *Update_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Update_statementContext) ExitRule

func (s *Update_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Update_statementContext) Expression

func (*Update_statementContext) FROM

func (*Update_statementContext) For_clause

func (*Update_statementContext) GLOBAL

func (*Update_statementContext) GetCursor_var

func (s *Update_statementContext) GetCursor_var() antlr.Token

func (*Update_statementContext) GetParser

func (s *Update_statementContext) GetParser() antlr.Parser

func (*Update_statementContext) GetRuleContext

func (s *Update_statementContext) GetRuleContext() antlr.RuleContext

func (*Update_statementContext) IsUpdate_statementContext

func (*Update_statementContext) IsUpdate_statementContext()

func (*Update_statementContext) LOCAL_ID

func (*Update_statementContext) LR_BRACKET

func (s *Update_statementContext) LR_BRACKET() antlr.TerminalNode

func (*Update_statementContext) OF

func (*Update_statementContext) Option_clause

func (*Update_statementContext) Output_clause

func (*Update_statementContext) PERCENT

func (*Update_statementContext) RR_BRACKET

func (s *Update_statementContext) RR_BRACKET() antlr.TerminalNode

func (*Update_statementContext) Rowset_function_limited

func (s *Update_statementContext) Rowset_function_limited() IRowset_function_limitedContext

func (*Update_statementContext) SEMI

func (*Update_statementContext) SET

func (*Update_statementContext) Search_condition_list

func (s *Update_statementContext) Search_condition_list() ISearch_condition_listContext

func (*Update_statementContext) SetCursor_var

func (s *Update_statementContext) SetCursor_var(v antlr.Token)

func (*Update_statementContext) TOP

func (*Update_statementContext) Table_sources

func (*Update_statementContext) ToStringTree

func (s *Update_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Update_statementContext) UPDATE

func (*Update_statementContext) Update_elem

func (*Update_statementContext) WHERE

func (*Update_statementContext) With_expression

func (s *Update_statementContext) With_expression() IWith_expressionContext

func (*Update_statementContext) With_table_hints

func (s *Update_statementContext) With_table_hints() IWith_table_hintsContext

type Update_statisticsContext

type Update_statisticsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUpdate_statisticsContext

func NewEmptyUpdate_statisticsContext() *Update_statisticsContext

func NewUpdate_statisticsContext

func NewUpdate_statisticsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_statisticsContext

func (*Update_statisticsContext) ALL

func (*Update_statisticsContext) DECIMAL

func (*Update_statisticsContext) EnterRule

func (s *Update_statisticsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Update_statisticsContext) ExitRule

func (s *Update_statisticsContext) ExitRule(listener antlr.ParseTreeListener)

func (*Update_statisticsContext) Full_table_name

func (*Update_statisticsContext) GetParser

func (s *Update_statisticsContext) GetParser() antlr.Parser

func (*Update_statisticsContext) GetRuleContext

func (s *Update_statisticsContext) GetRuleContext() antlr.RuleContext

func (*Update_statisticsContext) INDEX

func (*Update_statisticsContext) Id

func (*Update_statisticsContext) IsUpdate_statisticsContext

func (*Update_statisticsContext) IsUpdate_statisticsContext()

func (*Update_statisticsContext) STATISTICS

func (*Update_statisticsContext) ToStringTree

func (s *Update_statisticsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Update_statisticsContext) UPDATE

func (*Update_statisticsContext) USING

func (*Update_statisticsContext) VALUES

type Use_statementContext

type Use_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUse_statementContext

func NewEmptyUse_statementContext() *Use_statementContext

func NewUse_statementContext

func NewUse_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_statementContext

func (*Use_statementContext) EnterRule

func (s *Use_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Use_statementContext) ExitRule

func (s *Use_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Use_statementContext) GetDatabase

func (s *Use_statementContext) GetDatabase() IIdContext

func (*Use_statementContext) GetParser

func (s *Use_statementContext) GetParser() antlr.Parser

func (*Use_statementContext) GetRuleContext

func (s *Use_statementContext) GetRuleContext() antlr.RuleContext

func (*Use_statementContext) Id

func (*Use_statementContext) IsUse_statementContext

func (*Use_statementContext) IsUse_statementContext()

func (*Use_statementContext) SEMI

func (*Use_statementContext) SetDatabase

func (s *Use_statementContext) SetDatabase(v IIdContext)

func (*Use_statementContext) ToStringTree

func (s *Use_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Use_statementContext) USE

type Value_methodContext

type Value_methodContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyValue_methodContext

func NewEmptyValue_methodContext() *Value_methodContext

func NewValue_methodContext

func NewValue_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Value_methodContext

func (*Value_methodContext) AllDOT

func (s *Value_methodContext) AllDOT() []antlr.TerminalNode

func (*Value_methodContext) AllSTRING

func (s *Value_methodContext) AllSTRING() []antlr.TerminalNode

func (*Value_methodContext) COMMA

func (*Value_methodContext) DOT

func (*Value_methodContext) EVENTDATA

func (s *Value_methodContext) EVENTDATA() antlr.TerminalNode

func (*Value_methodContext) EnterRule

func (s *Value_methodContext) EnterRule(listener antlr.ParseTreeListener)

func (*Value_methodContext) ExitRule

func (s *Value_methodContext) ExitRule(listener antlr.ParseTreeListener)

func (*Value_methodContext) GetParser

func (s *Value_methodContext) GetParser() antlr.Parser

func (*Value_methodContext) GetRuleContext

func (s *Value_methodContext) GetRuleContext() antlr.RuleContext

func (*Value_methodContext) GetSqltype

func (s *Value_methodContext) GetSqltype() antlr.Token

func (*Value_methodContext) GetXquery

func (s *Value_methodContext) GetXquery() antlr.Token

func (*Value_methodContext) ID

func (*Value_methodContext) IsValue_methodContext

func (*Value_methodContext) IsValue_methodContext()

func (*Value_methodContext) LOCAL_ID

func (s *Value_methodContext) LOCAL_ID() antlr.TerminalNode

func (*Value_methodContext) LR_BRACKET

func (s *Value_methodContext) LR_BRACKET() antlr.TerminalNode

func (*Value_methodContext) PARAM_NODE

func (s *Value_methodContext) PARAM_NODE() antlr.TerminalNode

func (*Value_methodContext) Query_method

func (s *Value_methodContext) Query_method() IQuery_methodContext

func (*Value_methodContext) ROW

func (*Value_methodContext) RR_BRACKET

func (s *Value_methodContext) RR_BRACKET() antlr.TerminalNode

func (*Value_methodContext) STRING

func (*Value_methodContext) SetSqltype

func (s *Value_methodContext) SetSqltype(v antlr.Token)

func (*Value_methodContext) SetXquery

func (s *Value_methodContext) SetXquery(v antlr.Token)

func (*Value_methodContext) ToStringTree

func (s *Value_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Value_methodContext) VALUE

type View_attributeContext

type View_attributeContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyView_attributeContext

func NewEmptyView_attributeContext() *View_attributeContext

func NewView_attributeContext

func NewView_attributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_attributeContext

func (*View_attributeContext) ENCRYPTION

func (s *View_attributeContext) ENCRYPTION() antlr.TerminalNode

func (*View_attributeContext) EnterRule

func (s *View_attributeContext) EnterRule(listener antlr.ParseTreeListener)

func (*View_attributeContext) ExitRule

func (s *View_attributeContext) ExitRule(listener antlr.ParseTreeListener)

func (*View_attributeContext) GetParser

func (s *View_attributeContext) GetParser() antlr.Parser

func (*View_attributeContext) GetRuleContext

func (s *View_attributeContext) GetRuleContext() antlr.RuleContext

func (*View_attributeContext) IsView_attributeContext

func (*View_attributeContext) IsView_attributeContext()

func (*View_attributeContext) SCHEMABINDING

func (s *View_attributeContext) SCHEMABINDING() antlr.TerminalNode

func (*View_attributeContext) ToStringTree

func (s *View_attributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*View_attributeContext) VIEW_METADATA

func (s *View_attributeContext) VIEW_METADATA() antlr.TerminalNode

type Waitfor_conversationContext

type Waitfor_conversationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWaitfor_conversationContext

func NewEmptyWaitfor_conversationContext() *Waitfor_conversationContext

func NewWaitfor_conversationContext

func NewWaitfor_conversationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Waitfor_conversationContext

func (*Waitfor_conversationContext) COMMA

func (*Waitfor_conversationContext) EnterRule

func (s *Waitfor_conversationContext) EnterRule(listener antlr.ParseTreeListener)

func (*Waitfor_conversationContext) ExitRule

func (s *Waitfor_conversationContext) ExitRule(listener antlr.ParseTreeListener)

func (*Waitfor_conversationContext) GetParser

func (s *Waitfor_conversationContext) GetParser() antlr.Parser

func (*Waitfor_conversationContext) GetRuleContext

func (s *Waitfor_conversationContext) GetRuleContext() antlr.RuleContext

func (*Waitfor_conversationContext) GetTimeout

func (s *Waitfor_conversationContext) GetTimeout() ITimeContext

func (*Waitfor_conversationContext) Get_conversation

func (*Waitfor_conversationContext) IsWaitfor_conversationContext

func (*Waitfor_conversationContext) IsWaitfor_conversationContext()

func (*Waitfor_conversationContext) LR_BRACKET

func (*Waitfor_conversationContext) RR_BRACKET

func (*Waitfor_conversationContext) SEMI

func (*Waitfor_conversationContext) SetTimeout

func (s *Waitfor_conversationContext) SetTimeout(v ITimeContext)

func (*Waitfor_conversationContext) TIMEOUT

func (*Waitfor_conversationContext) Time

func (*Waitfor_conversationContext) ToStringTree

func (s *Waitfor_conversationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Waitfor_conversationContext) WAITFOR

type Waitfor_statementContext

type Waitfor_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWaitfor_statementContext

func NewEmptyWaitfor_statementContext() *Waitfor_statementContext

func NewWaitfor_statementContext

func NewWaitfor_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Waitfor_statementContext

func (*Waitfor_statementContext) COMMA

func (*Waitfor_statementContext) DELAY

func (*Waitfor_statementContext) EnterRule

func (s *Waitfor_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*Waitfor_statementContext) ExitRule

func (s *Waitfor_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*Waitfor_statementContext) Expression

func (*Waitfor_statementContext) GetParser

func (s *Waitfor_statementContext) GetParser() antlr.Parser

func (*Waitfor_statementContext) GetRuleContext

func (s *Waitfor_statementContext) GetRuleContext() antlr.RuleContext

func (*Waitfor_statementContext) IsWaitfor_statementContext

func (*Waitfor_statementContext) IsWaitfor_statementContext()

func (*Waitfor_statementContext) Receive_statement

func (s *Waitfor_statementContext) Receive_statement() IReceive_statementContext

func (*Waitfor_statementContext) SEMI

func (*Waitfor_statementContext) TIME

func (*Waitfor_statementContext) TIMEOUT

func (*Waitfor_statementContext) Time

func (*Waitfor_statementContext) ToStringTree

func (s *Waitfor_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Waitfor_statementContext) WAITFOR

type While_statementContext

type While_statementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWhile_statementContext

func NewEmptyWhile_statementContext() *While_statementContext

func NewWhile_statementContext

func NewWhile_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *While_statementContext

func (*While_statementContext) BREAK

func (*While_statementContext) CONTINUE

func (*While_statementContext) EnterRule

func (s *While_statementContext) EnterRule(listener antlr.ParseTreeListener)

func (*While_statementContext) ExitRule

func (s *While_statementContext) ExitRule(listener antlr.ParseTreeListener)

func (*While_statementContext) GetParser

func (s *While_statementContext) GetParser() antlr.Parser

func (*While_statementContext) GetRuleContext

func (s *While_statementContext) GetRuleContext() antlr.RuleContext

func (*While_statementContext) IsWhile_statementContext

func (*While_statementContext) IsWhile_statementContext()

func (*While_statementContext) SEMI

func (*While_statementContext) Search_condition

func (s *While_statementContext) Search_condition() ISearch_conditionContext

func (*While_statementContext) Sql_clause

func (*While_statementContext) ToStringTree

func (s *While_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*While_statementContext) WHILE

type Window_frame_boundContext

type Window_frame_boundContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWindow_frame_boundContext

func NewEmptyWindow_frame_boundContext() *Window_frame_boundContext

func NewWindow_frame_boundContext

func NewWindow_frame_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_frame_boundContext

func (*Window_frame_boundContext) EnterRule

func (s *Window_frame_boundContext) EnterRule(listener antlr.ParseTreeListener)

func (*Window_frame_boundContext) ExitRule

func (s *Window_frame_boundContext) ExitRule(listener antlr.ParseTreeListener)

func (*Window_frame_boundContext) GetParser

func (s *Window_frame_boundContext) GetParser() antlr.Parser

func (*Window_frame_boundContext) GetRuleContext

func (s *Window_frame_boundContext) GetRuleContext() antlr.RuleContext

func (*Window_frame_boundContext) IsWindow_frame_boundContext

func (*Window_frame_boundContext) IsWindow_frame_boundContext()

func (*Window_frame_boundContext) ToStringTree

func (s *Window_frame_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Window_frame_boundContext) Window_frame_following

func (s *Window_frame_boundContext) Window_frame_following() IWindow_frame_followingContext

func (*Window_frame_boundContext) Window_frame_preceding

func (s *Window_frame_boundContext) Window_frame_preceding() IWindow_frame_precedingContext

type Window_frame_extentContext

type Window_frame_extentContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWindow_frame_extentContext

func NewEmptyWindow_frame_extentContext() *Window_frame_extentContext

func NewWindow_frame_extentContext

func NewWindow_frame_extentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_frame_extentContext

func (*Window_frame_extentContext) AND

func (*Window_frame_extentContext) AllWindow_frame_bound

func (s *Window_frame_extentContext) AllWindow_frame_bound() []IWindow_frame_boundContext

func (*Window_frame_extentContext) BETWEEN

func (*Window_frame_extentContext) EnterRule

func (s *Window_frame_extentContext) EnterRule(listener antlr.ParseTreeListener)

func (*Window_frame_extentContext) ExitRule

func (s *Window_frame_extentContext) ExitRule(listener antlr.ParseTreeListener)

func (*Window_frame_extentContext) GetParser

func (s *Window_frame_extentContext) GetParser() antlr.Parser

func (*Window_frame_extentContext) GetRuleContext

func (s *Window_frame_extentContext) GetRuleContext() antlr.RuleContext

func (*Window_frame_extentContext) IsWindow_frame_extentContext

func (*Window_frame_extentContext) IsWindow_frame_extentContext()

func (*Window_frame_extentContext) ToStringTree

func (s *Window_frame_extentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Window_frame_extentContext) Window_frame_bound

func (*Window_frame_extentContext) Window_frame_preceding

func (s *Window_frame_extentContext) Window_frame_preceding() IWindow_frame_precedingContext

type Window_frame_followingContext

type Window_frame_followingContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWindow_frame_followingContext

func NewEmptyWindow_frame_followingContext() *Window_frame_followingContext

func NewWindow_frame_followingContext

func NewWindow_frame_followingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_frame_followingContext

func (*Window_frame_followingContext) DECIMAL

func (*Window_frame_followingContext) EnterRule

func (s *Window_frame_followingContext) EnterRule(listener antlr.ParseTreeListener)

func (*Window_frame_followingContext) ExitRule

func (*Window_frame_followingContext) FOLLOWING

func (*Window_frame_followingContext) GetParser

func (*Window_frame_followingContext) GetRuleContext

func (s *Window_frame_followingContext) GetRuleContext() antlr.RuleContext

func (*Window_frame_followingContext) IsWindow_frame_followingContext

func (*Window_frame_followingContext) IsWindow_frame_followingContext()

func (*Window_frame_followingContext) ToStringTree

func (s *Window_frame_followingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Window_frame_followingContext) UNBOUNDED

type Window_frame_precedingContext

type Window_frame_precedingContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWindow_frame_precedingContext

func NewEmptyWindow_frame_precedingContext() *Window_frame_precedingContext

func NewWindow_frame_precedingContext

func NewWindow_frame_precedingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_frame_precedingContext

func (*Window_frame_precedingContext) CURRENT

func (*Window_frame_precedingContext) DECIMAL

func (*Window_frame_precedingContext) EnterRule

func (s *Window_frame_precedingContext) EnterRule(listener antlr.ParseTreeListener)

func (*Window_frame_precedingContext) ExitRule

func (*Window_frame_precedingContext) GetParser

func (*Window_frame_precedingContext) GetRuleContext

func (s *Window_frame_precedingContext) GetRuleContext() antlr.RuleContext

func (*Window_frame_precedingContext) IsWindow_frame_precedingContext

func (*Window_frame_precedingContext) IsWindow_frame_precedingContext()

func (*Window_frame_precedingContext) PRECEDING

func (*Window_frame_precedingContext) ROW

func (*Window_frame_precedingContext) ToStringTree

func (s *Window_frame_precedingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Window_frame_precedingContext) UNBOUNDED

type With_expressionContext

type With_expressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWith_expressionContext

func NewEmptyWith_expressionContext() *With_expressionContext

func NewWith_expressionContext

func NewWith_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_expressionContext

func (*With_expressionContext) AS

func (*With_expressionContext) AllCOMMA

func (s *With_expressionContext) AllCOMMA() []antlr.TerminalNode

func (*With_expressionContext) AllCommon_table_expression

func (s *With_expressionContext) AllCommon_table_expression() []ICommon_table_expressionContext

func (*With_expressionContext) AllLR_BRACKET

func (s *With_expressionContext) AllLR_BRACKET() []antlr.TerminalNode

func (*With_expressionContext) AllRR_BRACKET

func (s *With_expressionContext) AllRR_BRACKET() []antlr.TerminalNode

func (*With_expressionContext) BLOCKING_HIERARCHY

func (s *With_expressionContext) BLOCKING_HIERARCHY() antlr.TerminalNode

func (*With_expressionContext) COMMA

func (*With_expressionContext) Common_table_expression

func (s *With_expressionContext) Common_table_expression(i int) ICommon_table_expressionContext

func (*With_expressionContext) EnterRule

func (s *With_expressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*With_expressionContext) ExitRule

func (s *With_expressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*With_expressionContext) Full_column_name_list

func (s *With_expressionContext) Full_column_name_list() IFull_column_name_listContext

func (*With_expressionContext) GetParser

func (s *With_expressionContext) GetParser() antlr.Parser

func (*With_expressionContext) GetRuleContext

func (s *With_expressionContext) GetRuleContext() antlr.RuleContext

func (*With_expressionContext) IsWith_expressionContext

func (*With_expressionContext) IsWith_expressionContext()

func (*With_expressionContext) LR_BRACKET

func (s *With_expressionContext) LR_BRACKET(i int) antlr.TerminalNode

func (*With_expressionContext) RR_BRACKET

func (s *With_expressionContext) RR_BRACKET(i int) antlr.TerminalNode

func (*With_expressionContext) Select_statement

func (s *With_expressionContext) Select_statement() ISelect_statementContext

func (*With_expressionContext) ToStringTree

func (s *With_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*With_expressionContext) WITH

func (*With_expressionContext) XMLNAMESPACES

func (s *With_expressionContext) XMLNAMESPACES() antlr.TerminalNode

type With_table_hintsContext

type With_table_hintsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWith_table_hintsContext

func NewEmptyWith_table_hintsContext() *With_table_hintsContext

func NewWith_table_hintsContext

func NewWith_table_hintsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_table_hintsContext

func (*With_table_hintsContext) AllCOMMA

func (s *With_table_hintsContext) AllCOMMA() []antlr.TerminalNode

func (*With_table_hintsContext) AllTable_hint

func (s *With_table_hintsContext) AllTable_hint() []ITable_hintContext

func (*With_table_hintsContext) COMMA

func (*With_table_hintsContext) EnterRule

func (s *With_table_hintsContext) EnterRule(listener antlr.ParseTreeListener)

func (*With_table_hintsContext) ExitRule

func (s *With_table_hintsContext) ExitRule(listener antlr.ParseTreeListener)

func (*With_table_hintsContext) GetParser

func (s *With_table_hintsContext) GetParser() antlr.Parser

func (*With_table_hintsContext) GetRuleContext

func (s *With_table_hintsContext) GetRuleContext() antlr.RuleContext

func (*With_table_hintsContext) IsWith_table_hintsContext

func (*With_table_hintsContext) IsWith_table_hintsContext()

func (*With_table_hintsContext) LR_BRACKET

func (s *With_table_hintsContext) LR_BRACKET() antlr.TerminalNode

func (*With_table_hintsContext) RR_BRACKET

func (s *With_table_hintsContext) RR_BRACKET() antlr.TerminalNode

func (*With_table_hintsContext) Table_hint

func (*With_table_hintsContext) ToStringTree

func (s *With_table_hintsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*With_table_hintsContext) WITH

type Witness_optionContext

type Witness_optionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWitness_optionContext

func NewEmptyWitness_optionContext() *Witness_optionContext

func NewWitness_optionContext

func NewWitness_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Witness_optionContext

func (*Witness_optionContext) EnterRule

func (s *Witness_optionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Witness_optionContext) ExitRule

func (s *Witness_optionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Witness_optionContext) GetParser

func (s *Witness_optionContext) GetParser() antlr.Parser

func (*Witness_optionContext) GetRuleContext

func (s *Witness_optionContext) GetRuleContext() antlr.RuleContext

func (*Witness_optionContext) IsWitness_optionContext

func (*Witness_optionContext) IsWitness_optionContext()

func (*Witness_optionContext) OFF

func (*Witness_optionContext) ToStringTree

func (s *Witness_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Witness_optionContext) Witness_partner_equal

func (s *Witness_optionContext) Witness_partner_equal() IWitness_partner_equalContext

func (*Witness_optionContext) Witness_server

func (s *Witness_optionContext) Witness_server() IWitness_serverContext

type Witness_partner_equalContext

type Witness_partner_equalContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWitness_partner_equalContext

func NewEmptyWitness_partner_equalContext() *Witness_partner_equalContext

func NewWitness_partner_equalContext

func NewWitness_partner_equalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Witness_partner_equalContext

func (*Witness_partner_equalContext) EQUAL

func (*Witness_partner_equalContext) EnterRule

func (s *Witness_partner_equalContext) EnterRule(listener antlr.ParseTreeListener)

func (*Witness_partner_equalContext) ExitRule

func (*Witness_partner_equalContext) GetParser

func (s *Witness_partner_equalContext) GetParser() antlr.Parser

func (*Witness_partner_equalContext) GetRuleContext

func (s *Witness_partner_equalContext) GetRuleContext() antlr.RuleContext

func (*Witness_partner_equalContext) IsWitness_partner_equalContext

func (*Witness_partner_equalContext) IsWitness_partner_equalContext()

func (*Witness_partner_equalContext) ToStringTree

func (s *Witness_partner_equalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Witness_serverContext

type Witness_serverContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyWitness_serverContext

func NewEmptyWitness_serverContext() *Witness_serverContext

func NewWitness_serverContext

func NewWitness_serverContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Witness_serverContext

func (*Witness_serverContext) EnterRule

func (s *Witness_serverContext) EnterRule(listener antlr.ParseTreeListener)

func (*Witness_serverContext) ExitRule

func (s *Witness_serverContext) ExitRule(listener antlr.ParseTreeListener)

func (*Witness_serverContext) GetParser

func (s *Witness_serverContext) GetParser() antlr.Parser

func (*Witness_serverContext) GetRuleContext

func (s *Witness_serverContext) GetRuleContext() antlr.RuleContext

func (*Witness_serverContext) IsWitness_serverContext

func (*Witness_serverContext) IsWitness_serverContext()

func (*Witness_serverContext) Partner_server

func (s *Witness_serverContext) Partner_server() IPartner_serverContext

func (*Witness_serverContext) ToStringTree

func (s *Witness_serverContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type XML_DATA_TYPE_FUNCContext

type XML_DATA_TYPE_FUNCContext struct {
	*Function_callContext
}

func NewXML_DATA_TYPE_FUNCContext

func NewXML_DATA_TYPE_FUNCContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *XML_DATA_TYPE_FUNCContext

func (*XML_DATA_TYPE_FUNCContext) EnterRule

func (s *XML_DATA_TYPE_FUNCContext) EnterRule(listener antlr.ParseTreeListener)

func (*XML_DATA_TYPE_FUNCContext) ExitRule

func (s *XML_DATA_TYPE_FUNCContext) ExitRule(listener antlr.ParseTreeListener)

func (*XML_DATA_TYPE_FUNCContext) GetRuleContext

func (s *XML_DATA_TYPE_FUNCContext) GetRuleContext() antlr.RuleContext

func (*XML_DATA_TYPE_FUNCContext) Xml_data_type_methods

func (s *XML_DATA_TYPE_FUNCContext) Xml_data_type_methods() IXml_data_type_methodsContext

type Xml_common_directivesContext

type Xml_common_directivesContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyXml_common_directivesContext

func NewEmptyXml_common_directivesContext() *Xml_common_directivesContext

func NewXml_common_directivesContext

func NewXml_common_directivesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_common_directivesContext

func (*Xml_common_directivesContext) BINARY_BASE64

func (s *Xml_common_directivesContext) BINARY_BASE64() antlr.TerminalNode

func (*Xml_common_directivesContext) COMMA

func (*Xml_common_directivesContext) EnterRule

func (s *Xml_common_directivesContext) EnterRule(listener antlr.ParseTreeListener)

func (*Xml_common_directivesContext) ExitRule

func (*Xml_common_directivesContext) GetParser

func (s *Xml_common_directivesContext) GetParser() antlr.Parser

func (*Xml_common_directivesContext) GetRuleContext

func (s *Xml_common_directivesContext) GetRuleContext() antlr.RuleContext

func (*Xml_common_directivesContext) IsXml_common_directivesContext

func (*Xml_common_directivesContext) IsXml_common_directivesContext()

func (*Xml_common_directivesContext) ROOT

func (*Xml_common_directivesContext) TYPE

func (*Xml_common_directivesContext) ToStringTree

func (s *Xml_common_directivesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Xml_data_type_methodsContext

type Xml_data_type_methodsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyXml_data_type_methodsContext

func NewEmptyXml_data_type_methodsContext() *Xml_data_type_methodsContext

func NewXml_data_type_methodsContext

func NewXml_data_type_methodsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_data_type_methodsContext

func (*Xml_data_type_methodsContext) EnterRule

func (s *Xml_data_type_methodsContext) EnterRule(listener antlr.ParseTreeListener)

func (*Xml_data_type_methodsContext) Exist_method

func (*Xml_data_type_methodsContext) ExitRule

func (*Xml_data_type_methodsContext) GetParser

func (s *Xml_data_type_methodsContext) GetParser() antlr.Parser

func (*Xml_data_type_methodsContext) GetRuleContext

func (s *Xml_data_type_methodsContext) GetRuleContext() antlr.RuleContext

func (*Xml_data_type_methodsContext) IsXml_data_type_methodsContext

func (*Xml_data_type_methodsContext) IsXml_data_type_methodsContext()

func (*Xml_data_type_methodsContext) Modify_method

func (*Xml_data_type_methodsContext) Nodes_method

func (*Xml_data_type_methodsContext) Query_method

func (*Xml_data_type_methodsContext) ToStringTree

func (s *Xml_data_type_methodsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Xml_data_type_methodsContext) Value_method

type Xml_schema_collectionContext

type Xml_schema_collectionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyXml_schema_collectionContext

func NewEmptyXml_schema_collectionContext() *Xml_schema_collectionContext

func NewXml_schema_collectionContext

func NewXml_schema_collectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_schema_collectionContext

func (*Xml_schema_collectionContext) AllID

func (*Xml_schema_collectionContext) DOT

func (*Xml_schema_collectionContext) EnterRule

func (s *Xml_schema_collectionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Xml_schema_collectionContext) ExitRule

func (*Xml_schema_collectionContext) GetParser

func (s *Xml_schema_collectionContext) GetParser() antlr.Parser

func (*Xml_schema_collectionContext) GetRuleContext

func (s *Xml_schema_collectionContext) GetRuleContext() antlr.RuleContext

func (*Xml_schema_collectionContext) ID

func (*Xml_schema_collectionContext) IsXml_schema_collectionContext

func (*Xml_schema_collectionContext) IsXml_schema_collectionContext()

func (*Xml_schema_collectionContext) ToStringTree

func (s *Xml_schema_collectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Xml_type_definitionContext

type Xml_type_definitionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyXml_type_definitionContext

func NewEmptyXml_type_definitionContext() *Xml_type_definitionContext

func NewXml_type_definitionContext

func NewXml_type_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_type_definitionContext

func (*Xml_type_definitionContext) CONTENT

func (*Xml_type_definitionContext) DOCUMENT

func (*Xml_type_definitionContext) EnterRule

func (s *Xml_type_definitionContext) EnterRule(listener antlr.ParseTreeListener)

func (*Xml_type_definitionContext) ExitRule

func (s *Xml_type_definitionContext) ExitRule(listener antlr.ParseTreeListener)

func (*Xml_type_definitionContext) GetParser

func (s *Xml_type_definitionContext) GetParser() antlr.Parser

func (*Xml_type_definitionContext) GetRuleContext

func (s *Xml_type_definitionContext) GetRuleContext() antlr.RuleContext

func (*Xml_type_definitionContext) IsXml_type_definitionContext

func (*Xml_type_definitionContext) IsXml_type_definitionContext()

func (*Xml_type_definitionContext) LR_BRACKET

func (*Xml_type_definitionContext) RR_BRACKET

func (*Xml_type_definitionContext) ToStringTree

func (s *Xml_type_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*Xml_type_definitionContext) XML

func (*Xml_type_definitionContext) Xml_schema_collection

func (s *Xml_type_definitionContext) Xml_schema_collection() IXml_schema_collectionContext

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL