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