001package gudusoft.gsqlparser.sqlcmds; 002 003import gudusoft.gsqlparser.*; 004import gudusoft.gsqlparser.stmt.*; 005import gudusoft.gsqlparser.stmt.mssql.*; 006import gudusoft.gsqlparser.stmt.sybase.*; 007 008/** 009 * Sybase SQL command resolver. 010 * Handles Sybase-specific T-SQL statement recognition. 011 * Sybase shares most SQL syntax with Microsoft SQL Server but has some unique features. 012 * 013 * @since 3.1.0.9 014 */ 015public class TSqlCmdsSybase extends AbstractSqlCmds { 016 017 public TSqlCmdsSybase() { 018 super(EDbVendor.dbvsybase); 019 } 020 021 @Override 022 protected String getToken1Str(int token1) { 023 // Handle Sybase-specific reserved words (token codes > TBaseType.rrw_abort) 024 switch (token1) { 025 case TBaseType.rrw_sybase_dump: 026 return "dump"; 027 default: 028 return null; 029 } 030 } 031 032 @Override 033 protected void initializeCommands() { 034 // Sybase commands must be sorted alphabetically by token1 035 // Note: Sybase shares most commands with MSSQL but has some unique ones 036 037 // ADD commands 038 addCmd(TBaseType.rrw_add, "counter", "signature", ESqlStatementType.sstmssqladdsignature); 039 addCmd(TBaseType.rrw_add, "signature", ESqlStatementType.sstmssqladdsignature); 040 041 // ALTER commands 042 addCmd(TBaseType.rrw_alter, "application", "role", ESqlStatementType.sstmssqlalterapplicationrole); 043 addCmd(TBaseType.rrw_alter, "assembly", ESqlStatementType.sstmssqlalterassembly); 044 addCmd(TBaseType.rrw_alter, "asymmetric", "key", ESqlStatementType.sstmssqlalterasymmetrickey); 045 addCmd(TBaseType.rrw_alter, "authorization", ESqlStatementType.sstmssqlalterauthorization); 046 addCmd(TBaseType.rrw_alter, "certificate", ESqlStatementType.sstmssqlaltercertificate); 047 addCmd(TBaseType.rrw_alter, "credential", ESqlStatementType.sstmssqlaltercredential); 048 addCmd(TBaseType.rrw_alter, "database", ESqlStatementType.sstmssqlalterdatabase); 049 addCmd(TBaseType.rrw_alter, "endpoint", ESqlStatementType.sstmssqlalterendpoint); 050 addCmd(TBaseType.rrw_alter, "fulltext", "catalog", ESqlStatementType.sstmssqlalterfulltextcatalog); 051 addCmd(TBaseType.rrw_alter, "fulltext", "index", ESqlStatementType.sstmssqlalterfulltextindex); 052 addCmd(TBaseType.rrw_alter, "function", ESqlStatementType.sstmssqlalterfunction); 053 addCmd(TBaseType.rrw_alter, "index", ESqlStatementType.sstmssqlalterindex); 054 addCmd(TBaseType.rrw_alter, "login", ESqlStatementType.sstmssqlalterlogin); 055 addCmd(TBaseType.rrw_alter, "master", "key", ESqlStatementType.sstmssqlaltermasterkey); 056 addCmd(TBaseType.rrw_alter, "message", "type", ESqlStatementType.sstmssqlaltermessagetype); 057 addCmd(TBaseType.rrw_alter, "partition", "function", ESqlStatementType.sstmssqlalterpartitionfunction); 058 addCmd(TBaseType.rrw_alter, "partition", "scheme", ESqlStatementType.sstmssqlalterpartitionscheme); 059 addCmd(TBaseType.rrw_alter, "proc", ESqlStatementType.sstmssqlalterprocedure); 060 addCmd(TBaseType.rrw_alter, "procedure", ESqlStatementType.sstmssqlalterprocedure); 061 addCmd(TBaseType.rrw_alter, "queue", ESqlStatementType.sstmssqlalterqueue); 062 addCmd(TBaseType.rrw_alter, "remote", "service", "binding", ESqlStatementType.sstmssqlalterremoteservicebinding); 063 addCmd(TBaseType.rrw_alter, "role", ESqlStatementType.sstmssqlalterrole); 064 addCmd(TBaseType.rrw_alter, "route", ESqlStatementType.sstmssqlalterroute); 065 addCmd(TBaseType.rrw_alter, "schema", ESqlStatementType.sstmssqlalterschema); 066 addCmd(TBaseType.rrw_alter, "service", ESqlStatementType.sstmssqlalterservice); 067 addCmd(TBaseType.rrw_alter, "service", "master", "key", ESqlStatementType.sstmssqlalterservicemasterkey); 068 addCmd(TBaseType.rrw_alter, "symmetric", "key", ESqlStatementType.sstmssqlaltersymmetrickey); 069 addCmd(TBaseType.rrw_alter, "table", ESqlStatementType.sstaltertable); 070 addCmd(TBaseType.rrw_alter, "trigger", ESqlStatementType.sstmssqlaltertrigger); 071 addCmd(TBaseType.rrw_alter, "user", ESqlStatementType.sstmssqlalteruser); 072 addCmd(TBaseType.rrw_alter, "view", ESqlStatementType.sstmssqlalterview); 073 addCmd(TBaseType.rrw_alter, "xml", "schema", "collection", ESqlStatementType.sstmssqlalterxmlschemacollection); 074 075 // BACKUP commands 076 addCmd(TBaseType.rrw_backup, "certificate", ESqlStatementType.sstmssqlbackupcertificate); 077 addCmd(TBaseType.rrw_backup, "database", ESqlStatementType.sstmssqlbackupdatabase); 078 addCmd(TBaseType.rrw_backup, "log", ESqlStatementType.sstmssqlbackuplog); 079 addCmd(TBaseType.rrw_backup, "master", "key", ESqlStatementType.sstmssqlbackupmasterkey); 080 addCmd(TBaseType.rrw_backup, "service", "master", "key", ESqlStatementType.sstmssqlbackupservicemasterkey); 081 082 // BEGIN commands 083 addCmd(TBaseType.rrw_begin, "catch", ESqlStatementType.sstmssqlbegincatch); 084 addCmd(TBaseType.rrw_begin, "conversation", "timer", ESqlStatementType.sstmssqlbeginconversationtimer); 085 addCmd(TBaseType.rrw_begin, "dialog", ESqlStatementType.sstmssqlbegindialog); 086 addCmd(TBaseType.rrw_begin, "distributed", ESqlStatementType.sstmssqlbegindistributed); 087 addCmd(TBaseType.rrw_begin, "tran", ESqlStatementType.sstmssqlbegintran); 088 addCmd(TBaseType.rrw_begin, "transaction", ESqlStatementType.sstmssqlbegintran); 089 addCmd(TBaseType.rrw_begin, "try", ESqlStatementType.sstmssqlbegintry); 090 091 // BREAK 092 addCmd(TBaseType.rrw_break, ESqlStatementType.sstbreak); 093 094 // BULK INSERT 095 addCmd(TBaseType.rrw_bulk, "insert", ESqlStatementType.sstmssqlbulkinsert); 096 097 // CALL 098 addCmd(TBaseType.rrw_call, ESqlStatementType.sstcall); 099 100 // CHECKPOINT 101 addCmd(TBaseType.rrw_checkpoint, ESqlStatementType.sstmssqlcheckpoint); 102 103 // CLOSE commands 104 addCmd(TBaseType.rrw_close, ESqlStatementType.sstmssqlclose); 105 addCmd(TBaseType.rrw_close, "all", "symmetric", "keys", ESqlStatementType.sstmssqlclosesymmetrickey); 106 addCmd(TBaseType.rrw_close, "master", "key", ESqlStatementType.sstmssqlclosemasterkey); 107 addCmd(TBaseType.rrw_close, "symmetric", "key", ESqlStatementType.sstmssqlclosesymmetrickey); 108 109 // COMMIT 110 addCmd(TBaseType.rrw_commit, ESqlStatementType.sstmssqlcommit); 111 addCmd(TBaseType.rrw_commit, "work", ESqlStatementType.sstmssqlcommit); 112 addCmd(TBaseType.rrw_commit, "tran", ESqlStatementType.sstmssqlcommit); 113 addCmd(TBaseType.rrw_commit, "transaction", ESqlStatementType.sstmssqlcommit); 114 115 // CONTINUE 116 addCmd(TBaseType.rrw_continue, ESqlStatementType.sstmssqlcontinue); 117 118 // CREATE commands 119 addCmd(TBaseType.rrw_create, "aggregate", ESqlStatementType.sstmssqlcreateaggregate); 120 addCmd(TBaseType.rrw_create, "application", "role", ESqlStatementType.sstmssqlcreateapplicationrole); 121 addCmd(TBaseType.rrw_create, "assembly", ESqlStatementType.sstmssqlcreateassembly); 122 addCmd(TBaseType.rrw_create, "asymmetric", "key", ESqlStatementType.sstmssqlcreateasymmetrickey); 123 addCmd(TBaseType.rrw_create, "certificate", ESqlStatementType.sstmssqlcreatecertificate); 124 addCmd(TBaseType.rrw_create, "clustered", "index", ESqlStatementType.sstcreateindex); 125 addCmd(TBaseType.rrw_create, "contract", ESqlStatementType.sstmssqlcreatecontract); 126 addCmd(TBaseType.rrw_create, "credential", ESqlStatementType.sstmssqlcreatecredential); 127 addCmd(TBaseType.rrw_create, "database", ESqlStatementType.sstcreatedatabase); 128 addCmd(TBaseType.rrw_create, "default", ESqlStatementType.sstmssqlcreatedefault); 129 addCmd(TBaseType.rrw_create, "endpoint", ESqlStatementType.sstmssqlcreateendpoint); 130 addCmd(TBaseType.rrw_create, "event", "notification", ESqlStatementType.sstmssqlcreateeventnotification); 131 addCmd(TBaseType.rrw_create, "fulltext", "catalog", ESqlStatementType.sstmssqlcreatefulltextcatalog); 132 addCmd(TBaseType.rrw_create, "fulltext", "index", ESqlStatementType.sstmssqlcreatefulltextindex); 133 addCmd(TBaseType.rrw_create, "function", ESqlStatementType.sstmssqlcreatefunction); 134 addCmd(TBaseType.rrw_create, "index", ESqlStatementType.sstcreateindex); 135 addCmd(TBaseType.rrw_create, "login", ESqlStatementType.sstmssqlcreatelogin); 136 addCmd(TBaseType.rrw_create, "master", "key", ESqlStatementType.sstmssqlcreatemasterkey); 137 addCmd(TBaseType.rrw_create, "message", "type", ESqlStatementType.sstmssqlcreatemessagetype); 138 addCmd(TBaseType.rrw_create, "nonclustered", "index", ESqlStatementType.sstcreateindex); 139 addCmd(TBaseType.rrw_create, "or", "replace", "function", ESqlStatementType.sstmssqlcreatefunction); 140 addCmd(TBaseType.rrw_create, "or", "replace", "proc", ESqlStatementType.sstmssqlcreateprocedure); 141 addCmd(TBaseType.rrw_create, "or", "replace", "procedure", ESqlStatementType.sstmssqlcreateprocedure); 142 addCmd(TBaseType.rrw_create, "partition", "function", ESqlStatementType.sstmssqlcreatepartitionfunction); 143 addCmd(TBaseType.rrw_create, "partition", "scheme", ESqlStatementType.sstmssqlcreatepartitionscheme); 144 addCmd(TBaseType.rrw_create, "proc", ESqlStatementType.sstmssqlcreateprocedure); 145 addCmd(TBaseType.rrw_create, "procedure", ESqlStatementType.sstmssqlcreateprocedure); 146 addCmd(TBaseType.rrw_create, "queue", ESqlStatementType.sstmssqlcreatequeue); 147 addCmd(TBaseType.rrw_create, "remote", "service", "binding", ESqlStatementType.sstmssqlcreateremoteservicebinding); 148 addCmd(TBaseType.rrw_create, "role", ESqlStatementType.sstmssqlcreaterole); 149 addCmd(TBaseType.rrw_create, "route", ESqlStatementType.sstmssqlcreateroute); 150 addCmd(TBaseType.rrw_create, "rule", ESqlStatementType.sstmssqlcreaterule); 151 addCmd(TBaseType.rrw_create, "schema", ESqlStatementType.sstmssqlcreateschema); 152 addCmd(TBaseType.rrw_create, "service", ESqlStatementType.sstmssqlcreateservice); 153 addCmd(TBaseType.rrw_create, "statistics", ESqlStatementType.sstmssqlcreatestatistics); 154 addCmd(TBaseType.rrw_create, "symmetric", "key", ESqlStatementType.sstmssqlcreatesymmetrickey); 155 addCmd(TBaseType.rrw_create, "synonym", ESqlStatementType.sstmssqlcreatesynonym); 156 addCmd(TBaseType.rrw_create, "table", ESqlStatementType.sstcreatetable); 157 addCmd(TBaseType.rrw_create, "trigger", ESqlStatementType.sstcreatetrigger); 158 addCmd(TBaseType.rrw_create, "type", ESqlStatementType.sstmssqlcreatetype); 159 addCmd(TBaseType.rrw_create, "unique", "clustered", "index", ESqlStatementType.sstcreateindex); 160 addCmd(TBaseType.rrw_create, "unique", "index", ESqlStatementType.sstcreateindex); 161 addCmd(TBaseType.rrw_create, "unique", "nonclustered", "index", ESqlStatementType.sstcreateindex); 162 addCmd(TBaseType.rrw_create, "user", ESqlStatementType.sstmssqlcreateuser); 163 addCmd(TBaseType.rrw_create, "view", ESqlStatementType.sstcreateview); 164 addCmd(TBaseType.rrw_create, "xml", "schema", "collection", ESqlStatementType.sstmssqlcreatexmlschemacollection); 165 166 // DBCC 167 addCmd(TBaseType.rrw_dbcc, ESqlStatementType.sstmssqldbcc); 168 169 // DEALLOCATE 170 addCmd(TBaseType.rrw_deallocate, ESqlStatementType.sstmssqldeallocate); 171 172 // DECLARE 173 addCmd(TBaseType.rrw_declare, ESqlStatementType.sstmssqldeclare); 174 175 // DELETE 176 addCmd(TBaseType.rrw_delete, ESqlStatementType.sstdelete); 177 178 // DELETE STATISTICS (Sybase-specific) 179 addCmd(TBaseType.rrw_delete, "shared", "statistics", ESqlStatementType.sstsybaseDeleteStatistics); 180 addCmd(TBaseType.rrw_delete, "statistics", ESqlStatementType.sstsybaseDeleteStatistics); 181 182 // DENY 183 addCmd(TBaseType.rrw_deny, ESqlStatementType.sstmssqldeny); 184 185 // DISABLE TRIGGER 186 addCmd(TBaseType.rrw_disable, "trigger", ESqlStatementType.sstmssqldisabletrigger); 187 188 // DROP commands 189 addCmd(TBaseType.rrw_drop, "aggregate", ESqlStatementType.sstmssqldropaggregate); 190 addCmd(TBaseType.rrw_drop, "application", "role", ESqlStatementType.sstmssqldropapplicationrole); 191 addCmd(TBaseType.rrw_drop, "assembly", ESqlStatementType.sstmssqldropassembly); 192 addCmd(TBaseType.rrw_drop, "asymmetric", "key", ESqlStatementType.sstmssqldropasymmetrickey); 193 addCmd(TBaseType.rrw_drop, "certificate", ESqlStatementType.sstmssqldropcertificate); 194 addCmd(TBaseType.rrw_drop, "contract", ESqlStatementType.sstmssqldropcontract); 195 addCmd(TBaseType.rrw_drop, "counter", "signature", ESqlStatementType.sstmssqldropsignature); 196 addCmd(TBaseType.rrw_drop, "credential", ESqlStatementType.sstmssqldropcredential); 197 addCmd(TBaseType.rrw_drop, "database", ESqlStatementType.sstmssqldropdatabase); 198 addCmd(TBaseType.rrw_drop, "default", ESqlStatementType.sstmssqldropdefault); 199 addCmd(TBaseType.rrw_drop, "endpoint", ESqlStatementType.sstmssqldropendpoint); 200 addCmd(TBaseType.rrw_drop, "event", "notification", ESqlStatementType.sstmssqldropeventnotification); 201 addCmd(TBaseType.rrw_drop, "fulltext", "catalog", ESqlStatementType.sstmssqldropfulltextcatalog); 202 addCmd(TBaseType.rrw_drop, "fulltext", "index", ESqlStatementType.sstmssqldropfulltextindex); 203 addCmd(TBaseType.rrw_drop, "function", ESqlStatementType.sstmssqldropfunction); 204 addCmd(TBaseType.rrw_drop, "index", ESqlStatementType.sstmssqldropindex); 205 addCmd(TBaseType.rrw_drop, "login", ESqlStatementType.sstmssqldroplogin); 206 addCmd(TBaseType.rrw_drop, "master", "key", ESqlStatementType.sstmssqldropmasterkey); 207 addCmd(TBaseType.rrw_drop, "message", "type", ESqlStatementType.sstmssqldropmessagetype); 208 addCmd(TBaseType.rrw_drop, "partition", "function", ESqlStatementType.sstmssqldroppartitionfunction); 209 addCmd(TBaseType.rrw_drop, "partition", "scheme", ESqlStatementType.sstmssqldroppartitionscheme); 210 addCmd(TBaseType.rrw_drop, "proc", ESqlStatementType.sstmssqldropprocedure); 211 addCmd(TBaseType.rrw_drop, "procedure", ESqlStatementType.sstmssqldropprocedure); 212 addCmd(TBaseType.rrw_drop, "queue", ESqlStatementType.sstmssqldropqueue); 213 addCmd(TBaseType.rrw_drop, "remote", "service", "binding", ESqlStatementType.sstmssqldropremoteservicebinding); 214 addCmd(TBaseType.rrw_drop, "role", ESqlStatementType.sstmssqldroprole); 215 addCmd(TBaseType.rrw_drop, "route", ESqlStatementType.sstmssqldroproute); 216 addCmd(TBaseType.rrw_drop, "rule", ESqlStatementType.sstmssqldroprule); 217 addCmd(TBaseType.rrw_drop, "schema", ESqlStatementType.sstmssqldropschema); 218 addCmd(TBaseType.rrw_drop, "service", ESqlStatementType.sstmssqldropservice); 219 addCmd(TBaseType.rrw_drop, "signature", ESqlStatementType.sstmssqldropsignature); 220 addCmd(TBaseType.rrw_drop, "statistics", ESqlStatementType.sstmssqldropstatistics); 221 addCmd(TBaseType.rrw_drop, "symmetric", "key", ESqlStatementType.sstmssqldropsymmetrickey); 222 addCmd(TBaseType.rrw_drop, "synonym", ESqlStatementType.sstmssqldropsynonym); 223 addCmd(TBaseType.rrw_drop, "table", ESqlStatementType.sstmssqldroptable); 224 addCmd(TBaseType.rrw_drop, "trigger", ESqlStatementType.sstmssqldroptrigger); 225 addCmd(TBaseType.rrw_drop, "type", ESqlStatementType.sstmssqldroptype); 226 addCmd(TBaseType.rrw_drop, "user", ESqlStatementType.sstmssqldropuser); 227 addCmd(TBaseType.rrw_drop, "view", ESqlStatementType.sstmssqldropview); 228 addCmd(TBaseType.rrw_drop, "xml", "schema", "collection", ESqlStatementType.sstmssqldropxmlschemacollection); 229 230 // DUMP (Sybase-specific) 231 addCmd(TBaseType.rrw_sybase_dump, "tran", ESqlStatementType.sstsybasedumpTran); 232 addCmd(TBaseType.rrw_sybase_dump, "transaction", ESqlStatementType.sstsybasedumpTran); 233 234 // ENABLE TRIGGER 235 addCmd(TBaseType.rrw_enable, "trigger", ESqlStatementType.sstmssqlenabletrigger); 236 237 // END CONVERSATION 238 addCmd(TBaseType.rrw_end, "conversation", ESqlStatementType.sstmssqlendconversation); 239 240 // EXEC/EXECUTE 241 addCmd(TBaseType.rrw_exec, ESqlStatementType.sstmssqlexec); 242 addCmd(TBaseType.rrw_exec, "as", "caller", ESqlStatementType.sstmssqlexecuteas); 243 addCmd(TBaseType.rrw_exec, "as", "login", ESqlStatementType.sstmssqlexecuteas); 244 addCmd(TBaseType.rrw_exec, "as", "user", ESqlStatementType.sstmssqlexecuteas); 245 addCmd(TBaseType.rrw_execute, ESqlStatementType.sstmssqlexec); 246 addCmd(TBaseType.rrw_execute, "as", "caller", ESqlStatementType.sstmssqlexecuteas); 247 addCmd(TBaseType.rrw_execute, "as", "login", ESqlStatementType.sstmssqlexecuteas); 248 addCmd(TBaseType.rrw_execute, "as", "user", ESqlStatementType.sstmssqlexecuteas); 249 250 // FETCH 251 addCmd(TBaseType.rrw_fetch, ESqlStatementType.sstmssqlfetch); 252 253 // GO 254 addCmd(TBaseType.rrw_go, ESqlStatementType.sstmssqlgo); 255 256 // GOTO 257 addCmd(TBaseType.rrw_goto, ESqlStatementType.sstmssqlgoto); 258 259 // GRANT 260 addCmd(TBaseType.rrw_grant, ESqlStatementType.sstmssqlgrant); 261 262 // IF 263 addCmd(TBaseType.rrw_if, ESqlStatementType.sstmssqlif); 264 265 // INSERT 266 addCmd(TBaseType.rrw_insert, ESqlStatementType.sstinsert); 267 268 // INSERT BULK (Sybase-specific) 269 addCmd(TBaseType.rrw_insert, "bulk", ESqlStatementType.sstsybaseInsertBulk); 270 271 // KILL 272 addCmd(TBaseType.rrw_kill, ESqlStatementType.sstmssqlkill); 273 addCmd(TBaseType.rrw_kill, "kill", "query", "notification", "subscription", ESqlStatementType.sstmssqlkillquerynotificationsubscription); 274 addCmd(TBaseType.rrw_kill, "stats", ESqlStatementType.sstmssqlkillstats); 275 276 // LOAD 277 addCmd(TBaseType.rrw_load, "table", ESqlStatementType.sstload); 278 279 // LOCK TABLE (Sybase-specific) 280 addCmd(TBaseType.rw_locktable, "table", ESqlStatementType.sstsybaselocktable); 281 282 // MERGE 283 addCmd(TBaseType.rrw_merge, ESqlStatementType.sstmerge); 284 285 // MOVE CONVERSATION 286 addCmd(TBaseType.rrw_move, "conversation", ESqlStatementType.sstmssqlmoveconversation); 287 288 // OPEN 289 addCmd(TBaseType.rrw_open, ESqlStatementType.sstmssqlopen); 290 addCmd(TBaseType.rrw_open, "master", "key", ESqlStatementType.sstmssqlopenmasterkey); 291 addCmd(TBaseType.rrw_open, "symmetric", "key", ESqlStatementType.sstmssqlopensymmetrickey); 292 293 // PRINT 294 addCmd(TBaseType.rrw_print, ESqlStatementType.sstmssqlprint); 295 296 // RAISERROR 297 addCmd(TBaseType.rrw_raiserror, ESqlStatementType.sstmssqlraiserror); 298 299 // READTEXT 300 addCmd(TBaseType.rrw_readtext, ESqlStatementType.sstmssqlreadtext); 301 302 // RECEIVE 303 addCmd(TBaseType.rrw_receive, ESqlStatementType.sstmssqlreceive); 304 305 // RECONFIGURE 306 addCmd(TBaseType.rrw_reconfigure, ESqlStatementType.sstmssqlreconfigure); 307 308 // RESTORE commands 309 addCmd(TBaseType.rrw_restore, "database", ESqlStatementType.sstmssqlrestoredatabase); 310 addCmd(TBaseType.rrw_restore, "filelistonly", ESqlStatementType.sstmssqlrestorefilelistonly); 311 addCmd(TBaseType.rrw_restore, "headeronly", ESqlStatementType.sstmssqlrestoreheaderonly); 312 addCmd(TBaseType.rrw_restore, "labelonly", ESqlStatementType.sstmssqlrestorelabelonly); 313 addCmd(TBaseType.rrw_restore, "log", ESqlStatementType.sstmssqlrestorelog); 314 addCmd(TBaseType.rrw_restore, "master", "key", ESqlStatementType.sstmssqlrestoremasterkey); 315 addCmd(TBaseType.rrw_restore, "rewindonly", ESqlStatementType.sstmssqlrestorerewindonly); 316 addCmd(TBaseType.rrw_restore, "service", "master", "key", ESqlStatementType.sstmssqlrestoreservicemasterkey); 317 addCmd(TBaseType.rrw_restore, "verifyonly", ESqlStatementType.sstmssqlrestoreverifyonly); 318 319 // RETURN 320 addCmd(TBaseType.rrw_return, ESqlStatementType.sstmssqlreturn); 321 322 // REVERT 323 addCmd(TBaseType.rrw_revert, ESqlStatementType.sstmssqlrevert); 324 325 // REVOKE 326 addCmd(TBaseType.rrw_revoke, ESqlStatementType.sstmssqlrevoke); 327 328 // ROLLBACK 329 addCmd(TBaseType.rrw_rollback, ESqlStatementType.sstmssqlrollback); 330 addCmd(TBaseType.rrw_rollback, "tran", ESqlStatementType.sstmssqlrollback); 331 addCmd(TBaseType.rrw_rollback, "transaction", ESqlStatementType.sstmssqlrollback); 332 addCmd(TBaseType.rrw_rollback, "work", ESqlStatementType.sstmssqlrollback); 333 334 // SAVE 335 addCmd(TBaseType.rrw_save, ESqlStatementType.sstmssqlsavetran); 336 addCmd(TBaseType.rrw_save, "tran", ESqlStatementType.sstmssqlsavetran); 337 addCmd(TBaseType.rrw_save, "transaction", ESqlStatementType.sstmssqlsavetran); 338 339 // SELECT 340 addCmd(TBaseType.rrw_select, ESqlStatementType.sstselect); 341 342 // SEND ON CONVERSATION 343 addCmd(TBaseType.rrw_send, "on", "conversation", ESqlStatementType.sstmssqlsendonconversation); 344 345 // SET 346 addCmd(TBaseType.rrw_set, ESqlStatementType.sstmssqlset); 347 348 // SETUSER 349 addCmd(TBaseType.rrw_setuser, ESqlStatementType.sstmssqlsetuser); 350 351 // SHUTDOWN 352 addCmd(TBaseType.rrw_shutdown, ESqlStatementType.sstmssqlshutdown); 353 354 // TRUNCATE TABLE 355 addCmd(TBaseType.rrw_truncate, "table", ESqlStatementType.sstmssqltruncatetable); 356 357 // UPDATE 358 addCmd(TBaseType.rrw_update, ESqlStatementType.sstupdate); 359 360 // UPDATE ALL STATISTICS 361 addCmd(TBaseType.rrw_update, "all", "statistics", ESqlStatementType.sstmssqlupdatestatistics); 362 363 // UPDATE INDEX STATISTICS (Sybase-specific) 364 addCmd(TBaseType.rrw_update, "index", "statistics", ESqlStatementType.sstsybaseupdateindexstatistics); 365 366 // UPDATE STATISTICS 367 addCmd(TBaseType.rrw_update, "statistics", ESqlStatementType.sstmssqlupdatestatistics); 368 369 // UPDATETEXT 370 addCmd(TBaseType.rrw_updatetext, ESqlStatementType.sstmssqlupdatetext); 371 372 // USE 373 addCmd(TBaseType.rrw_use, ESqlStatementType.sstmssqluse); 374 375 // WAITFOR 376 addCmd(TBaseType.rrw_waitfor, ESqlStatementType.sstmssqlwaitfor); 377 378 // WHILE 379 addCmd(TBaseType.rrw_while, ESqlStatementType.sstmssqlwhile); 380 381 // WITH XMLNAMESPACES 382 addCmd(TBaseType.rrw_with, "xmlnamespaces", ESqlStatementType.sstmssqlwithxmlnamespaces); 383 384 // WRITETEXT (Sybase-specific) 385 addCmd(TBaseType.rrw_writetext, ESqlStatementType.sstsybaseWritetext); 386 } 387 388 @Override 389 public ESqlStatementType getStatementTypeForToken(TSourceToken token) { 390 ESqlStatementType ret = ESqlStatementType.sstinvalid; 391 392 int lcpos = token.posinlist; 393 TSourceTokenList lcsourcetokenlist = token.container; 394 395 // Subquery after semicolon or at first line 396 if (token.tokentype == ETokenType.ttleftparenthesis) { // ( 397 int k = lcsourcetokenlist.solidtokenafterpos(lcpos, TBaseType.rrw_select, 1, "("); 398 if (k > 0) { 399 ret = ESqlStatementType.sstselect; 400 } 401 return ret; 402 } 403 404 // Find command using base class method 405// ensureInitialized(); 406// TSqlCmd cmd = finddbcmd(token, sqlCmdList); 407// if (cmd != null) { 408// ret = cmd.sqlstatementtype; 409// } 410 411 ret = super.getStatementTypeForToken (token); 412 413 // Execute can't be used to delimit other SQL 414 if (ret == ESqlStatementType.sstmssqlexec) { 415 ret = ESqlStatementType.sstinvalid; 416 } 417 418 // IF in expression context (e.g. SAP IQ / SQL Anywhere 419 // `set var = if cond then a else b endif`) is not a new statement 420 // boundary. Both the splitter and the runtime token-eating loop in 421 // `make_stmt` consult this method; without this check `make_stmt` 422 // would tear an IF expression out of the surrounding SET / RETURN / 423 // function-arg list and try to parse it as a Watcom IF statement, 424 // which the grammar then rejects. 425 if (ret == ESqlStatementType.sstmssqlif && lcsourcetokenlist != null) { 426 TSourceToken prev = lcsourcetokenlist.solidtokenbefore(lcpos); 427 if (isExpressionContext(prev)) { 428 ret = ESqlStatementType.sstinvalid; 429 } 430 } 431 432 return ret; 433 } 434 435 @Override 436 public TCustomSqlStatement issql(TSourceToken pcst, EFindSqlStateType pstate, TCustomSqlStatement psqlstatement) { 437 TCustomSqlStatement ret = null; 438 int k; 439 boolean lcisnewsql; 440 TSourceToken lcpprevsolidtoken, lcnextsolidtoken, lctoken; 441 442 gnewsqlstatementtype = ESqlStatementType.sstinvalid; 443 444 if ((pcst.tokencode == TBaseType.cmtdoublehyphen) 445 || (pcst.tokencode == TBaseType.cmtslashstar) 446 || (pcst.tokencode == TBaseType.lexspace) 447 || (pcst.tokencode == TBaseType.lexnewline) 448 || (pcst.tokentype == ETokenType.ttsemicolon)) { 449 return ret; 450 } 451 452 int lcpos = pcst.posinlist; 453 TSourceTokenList lcsourcetokenlist = pcst.container; 454 TCustomSqlStatement lccurrentsqlstatement = psqlstatement; 455 456 // subquery after semicolon || at first line 457 if ((pstate == EFindSqlStateType.stnormal) && (pcst.tokentype == ETokenType.ttleftparenthesis)) // ( 458 { 459 k = lcsourcetokenlist.solidtokenafterpos(lcpos, TBaseType.rrw_select, 1, "("); 460 if (k > 0) { 461 ret = new TSelectSqlStatement(this.vendor); 462 } 463 464 return ret; 465 } 466 467 // cte 468 if ((pstate == EFindSqlStateType.stnormal) && (pcst.tokencode == TBaseType.rrw_with)) { 469 ret = findcte(pcst); 470 if ((ret != null)) return ret; 471 } 472 473 // Find command using simple lookup (equivalent to findsybasecmd) 474// ensureInitialized(); 475// TSqlCmd cmd = finddbcmd(pcst, sqlCmdList); 476// gnewsqlstatementtype = (cmd != null) ? cmd.sqlstatementtype : ESqlStatementType.sstinvalid; 477 478 gnewsqlstatementtype = super.getStatementTypeForToken(pcst); 479 480 TSourceToken lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 481 switch (gnewsqlstatementtype) { // 482 case sstinvalid: { 483 if (pcst.tokencode == TBaseType.mslabel) { 484 ret = new TMssqlLabel(this.vendor); 485 } else 486 ret = null; 487 488 break; 489 } 490 case sstselect: { 491 lcisnewsql = true; 492 493 if (pstate != EFindSqlStateType.stnormal) { 494 // lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 495 if ((lcprevsolidtoken != null)) { 496 if (lcprevsolidtoken.tokentype == ETokenType.ttleftparenthesis) 497 lcisnewsql = false; //subqery 498 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_union) 499 lcisnewsql = false; 500 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_intersect) 501 lcisnewsql = false; 502 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_minus) 503 lcisnewsql = false; 504 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_except) 505 lcisnewsql = false; 506 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_return) 507 lcisnewsql = false; 508 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_as) { 509 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 510 lcisnewsql = false; 511 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 512 lcisnewsql = false; 513 } else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) { 514 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlset) 515 lcisnewsql = false; 516 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqldeclare) 517 lcisnewsql = false; 518 } 519 520 if (lcisnewsql && (lcprevsolidtoken.tokencode == TBaseType.rrw_all)) { 521 lcpprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcprevsolidtoken.posinlist); 522 if ((lcpprevsolidtoken != null)) { 523 if (lcpprevsolidtoken.tokencode == TBaseType.rrw_union) 524 lcisnewsql = false; 525 } 526 } 527 528 } 529 530 if ((lccurrentsqlstatement != null)) { 531 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 532 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 533 if ((lcprevsolidtoken != null)) { 534 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 535 lcisnewsql = false; 536 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 537 lcisnewsql = false; 538 } 539 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlrevoke) { 540 if ((lcprevsolidtoken != null)) { 541 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 542 lcisnewsql = false; 543 } 544 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) { 545 lcisnewsql = false; 546 } 547 } 548 549 } 550 551 if (lcisnewsql) 552 ret = new TSelectSqlStatement(this.vendor); 553 554 break; 555 556 } 557 case sstinsert: { 558 lcisnewsql = true; 559 if (pstate != EFindSqlStateType.stnormal) { 560 if ((lccurrentsqlstatement != null)) { 561 // merge 562 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 563 if (lcprevsolidtoken != null) { 564 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 565 lcisnewsql = false; 566 } 567 } 568 } 569 570 // bulk insert 571 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlbulkinsert) { 572 if ((lcprevsolidtoken != null)) { 573 if (lcprevsolidtoken.tokencode == TBaseType.rrw_bulk) 574 lcisnewsql = false; 575 } 576 } 577 578 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 579 if ((lcprevsolidtoken != null)) { 580 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 581 lcisnewsql = false; 582 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 583 lcisnewsql = false; 584 } 585 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlrevoke) { 586 if ((lcprevsolidtoken != null)) { 587 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 588 lcisnewsql = false; 589 } 590 } 591 592 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 593 if ((lcprevsolidtoken != null)) { 594 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 595 lcisnewsql = false; 596 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 597 lcisnewsql = false; 598 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 599 lcisnewsql = false; 600 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 601 lcisnewsql = false; 602 } 603 } 604 605 606 } 607 } 608 609 if (lcisnewsql) { 610 ret = new TInsertSqlStatement(this.vendor); 611 ret.dummytag = 1; // select stmt in insert is permitted 612 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) // iterate 613 { 614 if (lcsourcetokenlist.get(k).isnonsolidtoken()) continue; 615 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_values) break; 616 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_go) break; 617 if (lcsourcetokenlist.get(k).tokentype == ETokenType.ttsemicolon) break; 618 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_select) break; 619 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_execute) break; 620 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_exec) break; 621 } // for ( 622 if (k > lcsourcetokenlist.size() - 1) 623 k = lcsourcetokenlist.size() - 1; 624 625 for (int i = lcpos + 1; i <= k; i++) // iterate 626 { 627 lcsourcetokenlist.get(i).tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 628 } // for ( 629 630 } 631 632 break; 633 } 634 case sstsybaseInsertBulk: { 635 ret = new TInsertBulk(this.vendor); 636 break; 637 } 638 case sstupdate: { 639 lcisnewsql = true; 640 if (pstate != EFindSqlStateType.stnormal) { 641 // lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 642 if ((lcprevsolidtoken != null)) { // 643 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 644 lcisnewsql = false; 645 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 646 lcisnewsql = false; 647 } 648 649 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 650 if (TBaseType.assigned(lcnextsolidtoken)) { 651 if (lcnextsolidtoken.tokentype == ETokenType.ttleftparenthesis) { 652 k = lcsourcetokenlist.solidtokenafterpos(lcnextsolidtoken.posinlist, TBaseType.rrw_select, 1, "("); 653 if (k == 0) lcisnewsql = false; 654 } 655 } 656 657 658 if (TBaseType.assigned(lccurrentsqlstatement)) { 659 // merge 660 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 661 if (lcprevsolidtoken != null) { 662 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 663 lcisnewsql = false; 664 } 665 } 666 } 667 668 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 669 if (TBaseType.assigned(lcprevsolidtoken)) { 670 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 671 lcisnewsql = false; 672 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 673 lcisnewsql = false; 674 } 675 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlrevoke) { 676 if (TBaseType.assigned(lcprevsolidtoken)) { 677 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 678 lcisnewsql = false; 679 } 680 } 681 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 682 if (TBaseType.assigned(lcprevsolidtoken)) { 683 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 684 lcisnewsql = false; 685 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 686 lcisnewsql = false; 687 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 688 lcisnewsql = false; 689 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 690 lcisnewsql = false; 691 } 692 } 693 694 } 695 } 696 697 if (lcisnewsql) { 698 ret = new TUpdateSqlStatement(this.vendor); 699 ret.dummytag = 1; // means set clause in update is not found yet, used to seperate set clause from set statement 700 } 701 702 break; 703 } 704 case sstdelete: { 705 lcisnewsql = true; 706 707 if (pstate != EFindSqlStateType.stnormal) { 708 lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 709 if (TBaseType.assigned(lcprevsolidtoken)) { 710 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 711 lcisnewsql = false; 712 } 713 714 if (TBaseType.assigned(lccurrentsqlstatement)) { 715 // merge 716 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 717 if (lcprevsolidtoken != null) { 718 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 719 lcisnewsql = false; 720 } 721 } 722 } 723 724 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 725 if (TBaseType.assigned(lcprevsolidtoken)) { 726 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 727 lcisnewsql = false; 728 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 729 lcisnewsql = false; 730 } 731 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlrevoke) { 732 if (TBaseType.assigned(lcprevsolidtoken)) { 733 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 734 lcisnewsql = false; 735 } 736 } 737 738 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 739 if (TBaseType.assigned(lcprevsolidtoken)) { 740 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 741 lcisnewsql = false; 742 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 743 lcisnewsql = false; 744 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 745 lcisnewsql = false; 746 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 747 lcisnewsql = false; 748 } 749 } 750 751 } 752 } 753 754 if (lcisnewsql) 755 ret = new TDeleteSqlStatement(this.vendor); 756 757 break; 758 } 759 case sstcreatetable: { 760 ret = new TCreateTableSqlStatement(this.vendor); 761 break; 762 } 763 case sstcreateview: { 764 ret = new TCreateViewSqlStatement(this.vendor); 765 break; 766 } 767 case sstaltertable: { 768 ret = new TAlterTableStatement(this.vendor); 769 break; 770 } 771 case sstmssqlfetch: { 772 ret = new TMssqlFetch(this.vendor); 773 break; 774 } 775 case sstmssqlif: { 776 lcisnewsql = true; 777 if ((lccurrentsqlstatement != null) && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqldropprocedure)) { 778 lcisnewsql = false; 779 } 780 // SAP IQ / SQL Anywhere allow `IF cond THEN expr [ELSE expr] ENDIF` 781 // as an expression (e.g. RHS of SET, function argument). In those 782 // cases the IF token follows an expression introducer (`=`, `,`, 783 // `(`, arithmetic / comparison operators, or keywords like THEN / 784 // ELSE / AND / OR / RETURN). When that holds, the IF is NOT a new 785 // top-level statement; keep it inside the surrounding statement 786 // so the grammar's `if_expr` rule (reachable from basic3_expr) 787 // can consume it. 788 if (lcisnewsql && isExpressionContext(lcprevsolidtoken)) { 789 lcisnewsql = false; 790 } 791 if (lcisnewsql) { 792 ret = new TMssqlIfElse(this.vendor); 793 ret.dummytag = 1;// reduce to 0 while stmt find in 'if ( condtion stmt' || 'else stmt' 794 } 795 796 break; 797 } 798 case sstmssqlwhile: { 799 ret = new TMssqlIfElse(this.vendor); 800 ret.dummytag = 1;// reduce to 0 while stmt find in 'if ( condtion stmt' || 'else stmt' 801 break; 802 } 803 case sstmssqlcreateprocedure: 804 case sstmssqlalterprocedure: { 805 ret = new TMssqlCreateProcedure(this.vendor); 806 break; 807 } 808 case sstmssqlcreatefunction: 809 case sstmssqlalterfunction: { 810 ret = new TMssqlCreateFunction(this.vendor); 811 break; 812 } 813 case sstcreatetrigger: 814 case sstmssqlaltertrigger: { 815 ret = new TCreateTriggerStmt(this.vendor); 816 break; 817 } 818 case sstmssqlreturn: { 819 ret = new TMssqlReturn(this.vendor); 820 break; 821 } 822 case sstmssqlprint: { 823 ret = new TMssqlPrint(this.vendor); 824 break; 825 } 826 case sstmssqluse: { 827 ret = new TUseDatabase(this.vendor); 828 break; 829 } 830 case sstmssqlgo: { 831 ret = new TMssqlGo(this.vendor); 832 break; 833 } 834 case sstmssqlrevert: { 835 ret = new TMssqlRevert(this.vendor); 836 break; 837 } 838 case sstmssqlgrant: { 839 lcisnewsql = true; 840 // prev tokentext can't be with 841 if (pstate != EFindSqlStateType.stnormal) { 842 if (TBaseType.assigned(lcprevsolidtoken)) { 843 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) { 844 ret = null; 845 lcisnewsql = false; 846 } 847 } 848 } 849 if (lcisnewsql) { 850 ret = new TGrantStmt(this.vendor); 851 //ret.sqlstatementtype = gnewsqlstatementtype; 852 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) // iterate 853 { 854 lctoken = lcsourcetokenlist.get(k); 855 if (lctoken.isnonsolidtoken()) continue; 856 if (lctoken.tokencode == TBaseType.rrw_go) break; 857 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 858 if (lctoken.tokencode == TBaseType.rrw_to) break; 859 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 860 } 861 } 862 break; 863 } 864 case sstmssqldeclare: { 865 ret = new TMssqlDeclare(this.vendor); 866 break; 867 } 868 case sstmssqlcontinue: { 869 lcisnewsql = true; 870 if ((lccurrentsqlstatement != null) && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstload)) { 871 lcisnewsql = false; 872 } 873 if (lcisnewsql) { 874 ret = new TMssqlContinue(this.vendor); 875 } 876 877 break; 878 } 879 case sstbreak: { 880 ret = new TBreakStmt(this.vendor); 881 break; 882 } 883 case sstmssqlopen: { 884 ret = new TMssqlOpen(this.vendor); 885 break; 886 } 887 case sstmssqlclose: { 888 ret = new TMssqlClose(this.vendor); 889 break; 890 } 891 case sstmssqlbulkinsert: { 892 ret = new TMssqlBulkInsert(this.vendor); 893 break; 894 } 895 case sstmssqldeallocate: { 896 ret = new TMssqlDeallocate(this.vendor); 897 break; 898 } 899 case sstmssqlraiserror: { 900 ret = new TMssqlRaiserror(this.vendor); 901 break; 902 } 903 case sstmssqlgoto: { 904 ret = new TMssqlGoTo(this.vendor); 905 break; 906 } 907 case sstmssqldropview: { 908 ret = new TDropViewSqlStatement(this.vendor); 909 break; 910 } 911 case sstmssqldroptable: { 912 ret = new TDropTableSqlStatement(this.vendor); 913 break; 914 } 915 case sstmssqldropindex: { 916 ret = new TDropIndexSqlStatement(this.vendor); 917 break; 918 } 919 case sstmssqldroppartitionscheme: 920 ret = new TDropPartitionSchemeStmt(this.vendor); 921 break; 922 923 case sstmssqldropaggregate: 924 case sstmssqldropapplicationrole: 925 case sstmssqldropassembly: 926 case sstmssqldropasymmetrickey: 927 case sstmssqldropcertificate: 928 case sstmssqldropcontract: 929 case sstmssqldropcredential: 930 case sstmssqldropdefault: 931 case sstmssqldropendpoint: 932 case sstmssqldropeventnotification: 933 case sstmssqldropfulltextcatalog: 934 case sstmssqldropfulltextindex: 935 case sstmssqldropfunction: 936 case sstmssqldroplogin: 937 case sstmssqldropmasterkey: 938 case sstmssqldropmessagetype: 939 case sstmssqldroppartitionfunction: 940 case sstmssqldropprocedure: 941 case sstmssqldropqueue: 942 case sstmssqldropremoteservicebinding: 943 case sstmssqldroprole: 944 case sstmssqldroproute: 945 case sstmssqldroprule: 946 case sstmssqldropschema: 947 case sstmssqldropservice: 948 case sstmssqldropsignature: 949 case sstmssqldropstatistics: 950 case sstmssqldropsymmetrickey: 951 case sstmssqldroptrigger: 952 case sstmssqldroptype: 953 case sstmssqldropuser: 954 case sstmssqldropxmlschemacollection: 955 case sstmssqldropdatabase: { 956 ret = new TMssqlDropDbObject(EDbVendor.dbvsybase); 957 ret.sqlstatementtype = gnewsqlstatementtype; 958 break; 959 } 960 case sstmssqldropsynonym: { 961 ret = new TDropSynonymStmt(this.vendor); 962 break; 963 } 964 case sstmssqltruncatetable: { 965 ret = new TTruncateStatement(this.vendor); 966 break; 967 } 968 case sstmssqlbegintran: { 969 ret = new TBeginTran(this.vendor); 970 break; 971 } 972 case sstmssqlsavetran: { 973 ret = new TMssqlSaveTran(this.vendor); 974 break; 975 } 976 case sstmssqlcommit: { 977 lcisnewsql = true; 978 979 if (TBaseType.assigned(lcprevsolidtoken)) { 980 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) { 981 982 lcisnewsql = false; 983 } 984 } 985 986 if (lcisnewsql) { 987 ret = new TMssqlCommit(this.vendor); 988 } 989 990 break; 991 } 992 case sstmssqlrollback: { 993 ret = new TMssqlRollback(this.vendor); 994 break; 995 } 996 case sstmssqlreadtext: 997 case sstmssqldbcc: 998 case sstmssqlrestore: 999 case sstmssqlbackup: { 1000 ret = new TMssqlDummyStmt(this.vendor); 1001 ret.sqlstatementtype = gnewsqlstatementtype; 1002 break; 1003 } 1004 case sstcreateindex: { 1005 ret = new TCreateIndexSqlStatement(this.vendor); 1006 break; 1007 } 1008 case sstmssqlwaitfor: { 1009 ret = new TMssqlWaitFor(this.vendor); 1010 break; 1011 } 1012 case sstmerge: { 1013 lcisnewsql = true; 1014 1015 if (pstate != EFindSqlStateType.stnormal) { 1016 1017 if (lccurrentsqlstatement != null) { 1018 // merge union, merge join 1019 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect) { 1020 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1021 if (lcnextsolidtoken != null) { 1022 if ((lcnextsolidtoken.tokencode == TBaseType.rrw_union) || (lcnextsolidtoken.tokencode == TBaseType.rrw_join)) { 1023 lcisnewsql = false; 1024 } 1025 } 1026 } 1027 1028 } 1029 1030 TSourceToken lcnexttoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1031 if ((lcnexttoken != null)) { 1032 if (lcnexttoken.tokencode == TBaseType.rrw_sybase_partition) 1033 lcisnewsql = false; 1034 } 1035 1036 } 1037 1038 if (lcisnewsql) { 1039 ret = new TMergeSqlStatement(this.vendor); 1040 ret.sqlstatementtype = gnewsqlstatementtype; 1041 } 1042 1043 break; 1044 } 1045 case sstmssqlbegintry: 1046 case sstmssqlbegincatch: { 1047 ret = new TMssqlBlock(this.vendor); 1048 ret.sqlstatementtype = gnewsqlstatementtype; 1049 break; 1050 } 1051 case sstmssqlexec: { 1052 lcisnewsql = true; 1053 // prev tokentext can't be with 1054 if (pstate != EFindSqlStateType.stnormal) { 1055 if (TBaseType.assigned(lccurrentsqlstatement)) { 1056 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 1057 if (lccurrentsqlstatement.dummytag == 1) { 1058 lcisnewsql = false; 1059 lccurrentsqlstatement.dummytag = 0; // no select is permited after it 1060 } 1061 } 1062 1063 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 1064 if (TBaseType.assigned(lcprevsolidtoken)) { 1065 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 1066 lcisnewsql = false; 1067 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1068 lcisnewsql = false; 1069 } 1070 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlrevoke) { 1071 if (TBaseType.assigned(lcprevsolidtoken)) { 1072 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 1073 lcisnewsql = false; 1074 } 1075 } 1076 1077 1078 if ( 1079 (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateprocedure) 1080 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) 1081 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatefunction) 1082 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) 1083 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) 1084 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterfunction) 1085 ) { 1086 if (TBaseType.assigned(lcprevsolidtoken)) { 1087 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) 1088 lcisnewsql = false; 1089 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1090 lcisnewsql = false; 1091 } 1092 } 1093 } 1094 } 1095 if (lcisnewsql) { 1096 ret = new TMssqlExecute(this.vendor); 1097 } 1098 break; 1099 } 1100 case sstmssqlexecuteas: { 1101 lcisnewsql = true; 1102 // prev tokentext can't be with 1103 if (pstate != EFindSqlStateType.stnormal) { 1104 if (TBaseType.assigned(lccurrentsqlstatement)) { 1105 if ( 1106 (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateprocedure) 1107 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) 1108 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatefunction) 1109 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) 1110 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) 1111 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterfunction) 1112 ) { 1113 if (TBaseType.assigned(lcprevsolidtoken)) { 1114 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) 1115 lcisnewsql = false; 1116 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1117 lcisnewsql = false; 1118 } 1119 } 1120 } 1121 } 1122 if (lcisnewsql) { 1123 ret = new TMssqlExecuteAs(this.vendor); 1124 ret.sqlstatementtype = gnewsqlstatementtype; 1125 } 1126 break; 1127 } 1128 case sstmssqlset: { 1129 lcisnewsql = true; 1130 if (pstate != EFindSqlStateType.stnormal) { 1131 if (TBaseType.assigned(lccurrentsqlstatement)) { 1132 1133 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif) { 1134 TSourceToken lcPPToken = lcsourcetokenlist.searchToken(TBaseType.rrw_update, "", pcst, -10); 1135 if (TBaseType.assigned(lcPPToken)) { 1136 lcisnewsql = false; 1137 } 1138 } 1139 1140 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 1141 if (lcprevsolidtoken != null) { 1142 if (lcprevsolidtoken.tokencode == TBaseType.rrw_update) { 1143 lcisnewsql = false; 1144 } 1145 } 1146 } 1147 1148 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstupdate) { 1149 if (lccurrentsqlstatement.dummytag == 1) { 1150 //update statement still find set clause yet, so this is setclause in update statement 1151 lccurrentsqlstatement.dummytag = 0; 1152 lcisnewsql = false; 1153 } 1154 } 1155 } 1156 1157 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1158 if (TBaseType.assigned(lcnextsolidtoken)) { //set null, set default 1159 if ((TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "null") == 0) 1160 || (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "default") == 0)) { 1161 lcisnewsql = false; 1162 } 1163 } 1164 1165 } 1166 1167 if (lcisnewsql) { 1168 ret = new TMssqlSet(this.vendor); 1169 } 1170 1171 break; 1172 } 1173 case sstmssqlupdatetext: { 1174 ret = new TMssqlUpdateText(this.vendor); 1175 break; 1176 } 1177 case sstmssqlendconversation: { 1178 ret = new TMssqlEndConversation(this.vendor); 1179 break; 1180 } 1181 case sstmssqlbegindialog: { 1182 ret = new TMssqlBeginDialog(this.vendor); 1183 break; 1184 } 1185 case sstmssqlsendonconversation: { 1186 ret = new TMssqlSendOnConversation(this.vendor); 1187 break; 1188 } 1189 case sstmssqldisabletrigger: 1190 case sstmssqlenabletrigger: { 1191 lcisnewsql = true; 1192 if (TBaseType.assigned(lccurrentsqlstatement)) { 1193 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) 1194 lcisnewsql = false; 1195 } 1196 1197 if (lcisnewsql) { 1198 ret = new TDisableEnableTriggerStmt(this.vendor); 1199 ret.sqlstatementtype = gnewsqlstatementtype; 1200 } 1201 break; 1202 } 1203 case sstsybaseWritetext: { 1204 ret = new TSybaseWritetext(this.vendor); 1205 break; 1206 } 1207 case sstsybaseDeleteStatistics: { 1208 ret = new TSybaseDeleteStatistics(this.vendor); 1209 break; 1210 } 1211 case sstcall: { 1212 ret = new TCallStatement(this.vendor); 1213 break; 1214 } 1215 default: { 1216 ret = new TUnknownSqlStatement(this.vendor); 1217 ret.sqlstatementtype = gnewsqlstatementtype; 1218 break; 1219 } 1220 } // case 1221 1222 return ret; 1223 } 1224 1225 /** 1226 * Returns true when the given token would normally be followed by an 1227 * expression AND that expression position is currently parseable by the 1228 * Sybase grammar without re-enabling {@code if_expr -> basic_expr}. 1229 * 1230 * <p>This is deliberately narrow. We include {@code =} so the customer 1231 * pattern {@code SET var = if cond then a else b endif} works (handled 1232 * through the {@code RW_SET ColId} + {@code make_stmt} loop), and we 1233 * include boolean/comparison continuation keywords for cases like 1234 * {@code if a = if x then 1 else 2 endif then ...}. We deliberately 1235 * EXCLUDE punctuation that opens a structured sub-expression the 1236 * grammar cannot currently parse — {@code ,} and {@code (} — because 1237 * suppressing the splitter without a working grammar path just turns 1238 * the existing baseline error into a different (harder to recover) 1239 * error. 1240 */ 1241 private static boolean isExpressionContext(TSourceToken prev) { 1242 if (prev == null) { 1243 return false; 1244 } 1245 ETokenType tt = prev.tokentype; 1246 if (tt == ETokenType.ttequals 1247 || tt == ETokenType.ttplussign 1248 || tt == ETokenType.ttminussign 1249 || tt == ETokenType.ttasterisk 1250 || tt == ETokenType.ttslash 1251 || tt == ETokenType.ttpercent 1252 || tt == ETokenType.ttcaret 1253 || tt == ETokenType.ttlessthan 1254 || tt == ETokenType.ttgreaterthan) { 1255 return true; 1256 } 1257 int code = prev.tokencode; 1258 // Keywords whose RHS is always an expression. Deliberately narrow: 1259 // we only include keywords whose RHS can never be a fresh statement. 1260 // * RW_RETURN is excluded — Sybase/T-SQL allows a bare RETURN 1261 // followed by another statement without a semicolon. 1262 // * RW_SELECT / RW_WHERE / RW_HAVING / RW_BY / RW_VALUES are 1263 // excluded because if_expr is not currently reachable from 1264 // basic_expr; treating an IF after those tokens as expression 1265 // context would force the grammar to accept an unsupported parse. 1266 // Until basic_expr is taught the IF expression form, we let the 1267 // splitter keep the baseline behaviour of splitting on top-level 1268 // IF. 1269 return code == TBaseType.rrw_then 1270 || code == TBaseType.rrw_else 1271 || code == TBaseType.rrw_and 1272 || code == TBaseType.rrw_or 1273 || code == TBaseType.rrw_not 1274 || code == TBaseType.rrw_between 1275 || code == TBaseType.rrw_is 1276 || code == TBaseType.rrw_when; 1277 } 1278}