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 return ret; 419 } 420 421 @Override 422 public TCustomSqlStatement issql(TSourceToken pcst, EFindSqlStateType pstate, TCustomSqlStatement psqlstatement) { 423 TCustomSqlStatement ret = null; 424 int k; 425 boolean lcisnewsql; 426 TSourceToken lcpprevsolidtoken, lcnextsolidtoken, lctoken; 427 428 gnewsqlstatementtype = ESqlStatementType.sstinvalid; 429 430 if ((pcst.tokencode == TBaseType.cmtdoublehyphen) 431 || (pcst.tokencode == TBaseType.cmtslashstar) 432 || (pcst.tokencode == TBaseType.lexspace) 433 || (pcst.tokencode == TBaseType.lexnewline) 434 || (pcst.tokentype == ETokenType.ttsemicolon)) { 435 return ret; 436 } 437 438 int lcpos = pcst.posinlist; 439 TSourceTokenList lcsourcetokenlist = pcst.container; 440 TCustomSqlStatement lccurrentsqlstatement = psqlstatement; 441 442 // subquery after semicolon || at first line 443 if ((pstate == EFindSqlStateType.stnormal) && (pcst.tokentype == ETokenType.ttleftparenthesis)) // ( 444 { 445 k = lcsourcetokenlist.solidtokenafterpos(lcpos, TBaseType.rrw_select, 1, "("); 446 if (k > 0) { 447 ret = new TSelectSqlStatement(this.vendor); 448 } 449 450 return ret; 451 } 452 453 // cte 454 if ((pstate == EFindSqlStateType.stnormal) && (pcst.tokencode == TBaseType.rrw_with)) { 455 ret = findcte(pcst); 456 if ((ret != null)) return ret; 457 } 458 459 // Find command using simple lookup (equivalent to findsybasecmd) 460// ensureInitialized(); 461// TSqlCmd cmd = finddbcmd(pcst, sqlCmdList); 462// gnewsqlstatementtype = (cmd != null) ? cmd.sqlstatementtype : ESqlStatementType.sstinvalid; 463 464 gnewsqlstatementtype = super.getStatementTypeForToken(pcst); 465 466 TSourceToken lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 467 switch (gnewsqlstatementtype) { // 468 case sstinvalid: { 469 if (pcst.tokencode == TBaseType.mslabel) { 470 ret = new TMssqlLabel(this.vendor); 471 } else 472 ret = null; 473 474 break; 475 } 476 case sstselect: { 477 lcisnewsql = true; 478 479 if (pstate != EFindSqlStateType.stnormal) { 480 // lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 481 if ((lcprevsolidtoken != null)) { 482 if (lcprevsolidtoken.tokentype == ETokenType.ttleftparenthesis) 483 lcisnewsql = false; //subqery 484 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_union) 485 lcisnewsql = false; 486 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_intersect) 487 lcisnewsql = false; 488 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_minus) 489 lcisnewsql = false; 490 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_except) 491 lcisnewsql = false; 492 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_return) 493 lcisnewsql = false; 494 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_as) { 495 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 496 lcisnewsql = false; 497 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 498 lcisnewsql = false; 499 } else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) { 500 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlset) 501 lcisnewsql = false; 502 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqldeclare) 503 lcisnewsql = false; 504 } 505 506 if (lcisnewsql && (lcprevsolidtoken.tokencode == TBaseType.rrw_all)) { 507 lcpprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcprevsolidtoken.posinlist); 508 if ((lcpprevsolidtoken != null)) { 509 if (lcpprevsolidtoken.tokencode == TBaseType.rrw_union) 510 lcisnewsql = false; 511 } 512 } 513 514 } 515 516 if ((lccurrentsqlstatement != null)) { 517 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 518 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 519 if ((lcprevsolidtoken != null)) { 520 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 521 lcisnewsql = false; 522 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 523 lcisnewsql = false; 524 } 525 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlrevoke) { 526 if ((lcprevsolidtoken != null)) { 527 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 528 lcisnewsql = false; 529 } 530 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) { 531 lcisnewsql = false; 532 } 533 } 534 535 } 536 537 if (lcisnewsql) 538 ret = new TSelectSqlStatement(this.vendor); 539 540 break; 541 542 } 543 case sstinsert: { 544 lcisnewsql = true; 545 if (pstate != EFindSqlStateType.stnormal) { 546 if ((lccurrentsqlstatement != null)) { 547 // merge 548 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 549 if (lcprevsolidtoken != null) { 550 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 551 lcisnewsql = false; 552 } 553 } 554 } 555 556 // bulk insert 557 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlbulkinsert) { 558 if ((lcprevsolidtoken != null)) { 559 if (lcprevsolidtoken.tokencode == TBaseType.rrw_bulk) 560 lcisnewsql = false; 561 } 562 } 563 564 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 565 if ((lcprevsolidtoken != null)) { 566 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 567 lcisnewsql = false; 568 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 569 lcisnewsql = false; 570 } 571 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlrevoke) { 572 if ((lcprevsolidtoken != null)) { 573 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 574 lcisnewsql = false; 575 } 576 } 577 578 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 579 if ((lcprevsolidtoken != null)) { 580 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 581 lcisnewsql = false; 582 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 583 lcisnewsql = false; 584 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 585 lcisnewsql = false; 586 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 587 lcisnewsql = false; 588 } 589 } 590 591 592 } 593 } 594 595 if (lcisnewsql) { 596 ret = new TInsertSqlStatement(this.vendor); 597 ret.dummytag = 1; // select stmt in insert is permitted 598 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) // iterate 599 { 600 if (lcsourcetokenlist.get(k).isnonsolidtoken()) continue; 601 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_values) break; 602 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_go) break; 603 if (lcsourcetokenlist.get(k).tokentype == ETokenType.ttsemicolon) break; 604 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_select) break; 605 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_execute) break; 606 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_exec) break; 607 } // for ( 608 if (k > lcsourcetokenlist.size() - 1) 609 k = lcsourcetokenlist.size() - 1; 610 611 for (int i = lcpos + 1; i <= k; i++) // iterate 612 { 613 lcsourcetokenlist.get(i).tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 614 } // for ( 615 616 } 617 618 break; 619 } 620 case sstsybaseInsertBulk: { 621 ret = new TInsertBulk(this.vendor); 622 break; 623 } 624 case sstupdate: { 625 lcisnewsql = true; 626 if (pstate != EFindSqlStateType.stnormal) { 627 // lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 628 if ((lcprevsolidtoken != null)) { // 629 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 630 lcisnewsql = false; 631 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 632 lcisnewsql = false; 633 } 634 635 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 636 if (TBaseType.assigned(lcnextsolidtoken)) { 637 if (lcnextsolidtoken.tokentype == ETokenType.ttleftparenthesis) { 638 k = lcsourcetokenlist.solidtokenafterpos(lcnextsolidtoken.posinlist, TBaseType.rrw_select, 1, "("); 639 if (k == 0) lcisnewsql = false; 640 } 641 } 642 643 644 if (TBaseType.assigned(lccurrentsqlstatement)) { 645 // merge 646 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 647 if (lcprevsolidtoken != null) { 648 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 649 lcisnewsql = false; 650 } 651 } 652 } 653 654 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 655 if (TBaseType.assigned(lcprevsolidtoken)) { 656 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 657 lcisnewsql = false; 658 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 659 lcisnewsql = false; 660 } 661 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlrevoke) { 662 if (TBaseType.assigned(lcprevsolidtoken)) { 663 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 664 lcisnewsql = false; 665 } 666 } 667 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 668 if (TBaseType.assigned(lcprevsolidtoken)) { 669 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 670 lcisnewsql = false; 671 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 672 lcisnewsql = false; 673 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 674 lcisnewsql = false; 675 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 676 lcisnewsql = false; 677 } 678 } 679 680 } 681 } 682 683 if (lcisnewsql) { 684 ret = new TUpdateSqlStatement(this.vendor); 685 ret.dummytag = 1; // means set clause in update is not found yet, used to seperate set clause from set statement 686 } 687 688 break; 689 } 690 case sstdelete: { 691 lcisnewsql = true; 692 693 if (pstate != EFindSqlStateType.stnormal) { 694 lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 695 if (TBaseType.assigned(lcprevsolidtoken)) { 696 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 697 lcisnewsql = false; 698 } 699 700 if (TBaseType.assigned(lccurrentsqlstatement)) { 701 // merge 702 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 703 if (lcprevsolidtoken != null) { 704 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 705 lcisnewsql = false; 706 } 707 } 708 } 709 710 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 711 if (TBaseType.assigned(lcprevsolidtoken)) { 712 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 713 lcisnewsql = false; 714 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 715 lcisnewsql = false; 716 } 717 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlrevoke) { 718 if (TBaseType.assigned(lcprevsolidtoken)) { 719 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 720 lcisnewsql = false; 721 } 722 } 723 724 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 725 if (TBaseType.assigned(lcprevsolidtoken)) { 726 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 727 lcisnewsql = false; 728 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 729 lcisnewsql = false; 730 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 731 lcisnewsql = false; 732 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 733 lcisnewsql = false; 734 } 735 } 736 737 } 738 } 739 740 if (lcisnewsql) 741 ret = new TDeleteSqlStatement(this.vendor); 742 743 break; 744 } 745 case sstcreatetable: { 746 ret = new TCreateTableSqlStatement(this.vendor); 747 break; 748 } 749 case sstcreateview: { 750 ret = new TCreateViewSqlStatement(this.vendor); 751 break; 752 } 753 case sstaltertable: { 754 ret = new TAlterTableStatement(this.vendor); 755 break; 756 } 757 case sstmssqlfetch: { 758 ret = new TMssqlFetch(this.vendor); 759 break; 760 } 761 case sstmssqlif: { 762 lcisnewsql = true; 763 if ((lccurrentsqlstatement != null) && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqldropprocedure)) { 764 lcisnewsql = false; 765 } 766 if (lcisnewsql) { 767 ret = new TMssqlIfElse(this.vendor); 768 ret.dummytag = 1;// reduce to 0 while stmt find in 'if ( condtion stmt' || 'else stmt' 769 } 770 771 break; 772 } 773 case sstmssqlwhile: { 774 ret = new TMssqlIfElse(this.vendor); 775 ret.dummytag = 1;// reduce to 0 while stmt find in 'if ( condtion stmt' || 'else stmt' 776 break; 777 } 778 case sstmssqlcreateprocedure: 779 case sstmssqlalterprocedure: { 780 ret = new TMssqlCreateProcedure(this.vendor); 781 break; 782 } 783 case sstmssqlcreatefunction: 784 case sstmssqlalterfunction: { 785 ret = new TMssqlCreateFunction(this.vendor); 786 break; 787 } 788 case sstcreatetrigger: 789 case sstmssqlaltertrigger: { 790 ret = new TCreateTriggerStmt(this.vendor); 791 break; 792 } 793 case sstmssqlreturn: { 794 ret = new TMssqlReturn(this.vendor); 795 break; 796 } 797 case sstmssqlprint: { 798 ret = new TMssqlPrint(this.vendor); 799 break; 800 } 801 case sstmssqluse: { 802 ret = new TUseDatabase(this.vendor); 803 break; 804 } 805 case sstmssqlgo: { 806 ret = new TMssqlGo(this.vendor); 807 break; 808 } 809 case sstmssqlrevert: { 810 ret = new TMssqlRevert(this.vendor); 811 break; 812 } 813 case sstmssqlgrant: { 814 lcisnewsql = true; 815 // prev tokentext can't be with 816 if (pstate != EFindSqlStateType.stnormal) { 817 if (TBaseType.assigned(lcprevsolidtoken)) { 818 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) { 819 ret = null; 820 lcisnewsql = false; 821 } 822 } 823 } 824 if (lcisnewsql) { 825 ret = new TGrantStmt(this.vendor); 826 //ret.sqlstatementtype = gnewsqlstatementtype; 827 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) // iterate 828 { 829 lctoken = lcsourcetokenlist.get(k); 830 if (lctoken.isnonsolidtoken()) continue; 831 if (lctoken.tokencode == TBaseType.rrw_go) break; 832 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 833 if (lctoken.tokencode == TBaseType.rrw_to) break; 834 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 835 } 836 } 837 break; 838 } 839 case sstmssqldeclare: { 840 ret = new TMssqlDeclare(this.vendor); 841 break; 842 } 843 case sstmssqlcontinue: { 844 lcisnewsql = true; 845 if ((lccurrentsqlstatement != null) && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstload)) { 846 lcisnewsql = false; 847 } 848 if (lcisnewsql) { 849 ret = new TMssqlContinue(this.vendor); 850 } 851 852 break; 853 } 854 case sstbreak: { 855 ret = new TBreakStmt(this.vendor); 856 break; 857 } 858 case sstmssqlopen: { 859 ret = new TMssqlOpen(this.vendor); 860 break; 861 } 862 case sstmssqlclose: { 863 ret = new TMssqlClose(this.vendor); 864 break; 865 } 866 case sstmssqlbulkinsert: { 867 ret = new TMssqlBulkInsert(this.vendor); 868 break; 869 } 870 case sstmssqldeallocate: { 871 ret = new TMssqlDeallocate(this.vendor); 872 break; 873 } 874 case sstmssqlraiserror: { 875 ret = new TMssqlRaiserror(this.vendor); 876 break; 877 } 878 case sstmssqlgoto: { 879 ret = new TMssqlGoTo(this.vendor); 880 break; 881 } 882 case sstmssqldropview: { 883 ret = new TDropViewSqlStatement(this.vendor); 884 break; 885 } 886 case sstmssqldroptable: { 887 ret = new TDropTableSqlStatement(this.vendor); 888 break; 889 } 890 case sstmssqldropindex: { 891 ret = new TDropIndexSqlStatement(this.vendor); 892 break; 893 } 894 case sstmssqldroppartitionscheme: 895 ret = new TDropPartitionSchemeStmt(this.vendor); 896 break; 897 898 case sstmssqldropaggregate: 899 case sstmssqldropapplicationrole: 900 case sstmssqldropassembly: 901 case sstmssqldropasymmetrickey: 902 case sstmssqldropcertificate: 903 case sstmssqldropcontract: 904 case sstmssqldropcredential: 905 case sstmssqldropdefault: 906 case sstmssqldropendpoint: 907 case sstmssqldropeventnotification: 908 case sstmssqldropfulltextcatalog: 909 case sstmssqldropfulltextindex: 910 case sstmssqldropfunction: 911 case sstmssqldroplogin: 912 case sstmssqldropmasterkey: 913 case sstmssqldropmessagetype: 914 case sstmssqldroppartitionfunction: 915 case sstmssqldropprocedure: 916 case sstmssqldropqueue: 917 case sstmssqldropremoteservicebinding: 918 case sstmssqldroprole: 919 case sstmssqldroproute: 920 case sstmssqldroprule: 921 case sstmssqldropschema: 922 case sstmssqldropservice: 923 case sstmssqldropsignature: 924 case sstmssqldropstatistics: 925 case sstmssqldropsymmetrickey: 926 case sstmssqldroptrigger: 927 case sstmssqldroptype: 928 case sstmssqldropuser: 929 case sstmssqldropxmlschemacollection: 930 case sstmssqldropdatabase: { 931 ret = new TMssqlDropDbObject(EDbVendor.dbvsybase); 932 ret.sqlstatementtype = gnewsqlstatementtype; 933 break; 934 } 935 case sstmssqldropsynonym: { 936 ret = new TDropSynonymStmt(this.vendor); 937 break; 938 } 939 case sstmssqltruncatetable: { 940 ret = new TTruncateStatement(this.vendor); 941 break; 942 } 943 case sstmssqlbegintran: { 944 ret = new TBeginTran(this.vendor); 945 break; 946 } 947 case sstmssqlsavetran: { 948 ret = new TMssqlSaveTran(this.vendor); 949 break; 950 } 951 case sstmssqlcommit: { 952 lcisnewsql = true; 953 954 if (TBaseType.assigned(lcprevsolidtoken)) { 955 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) { 956 957 lcisnewsql = false; 958 } 959 } 960 961 if (lcisnewsql) { 962 ret = new TMssqlCommit(this.vendor); 963 } 964 965 break; 966 } 967 case sstmssqlrollback: { 968 ret = new TMssqlRollback(this.vendor); 969 break; 970 } 971 case sstmssqlreadtext: 972 case sstmssqldbcc: 973 case sstmssqlrestore: 974 case sstmssqlbackup: { 975 ret = new TMssqlDummyStmt(this.vendor); 976 ret.sqlstatementtype = gnewsqlstatementtype; 977 break; 978 } 979 case sstcreateindex: { 980 ret = new TCreateIndexSqlStatement(this.vendor); 981 break; 982 } 983 case sstmssqlwaitfor: { 984 ret = new TMssqlWaitFor(this.vendor); 985 break; 986 } 987 case sstmerge: { 988 lcisnewsql = true; 989 990 if (pstate != EFindSqlStateType.stnormal) { 991 992 if (lccurrentsqlstatement != null) { 993 // merge union, merge join 994 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect) { 995 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 996 if (lcnextsolidtoken != null) { 997 if ((lcnextsolidtoken.tokencode == TBaseType.rrw_union) || (lcnextsolidtoken.tokencode == TBaseType.rrw_join)) { 998 lcisnewsql = false; 999 } 1000 } 1001 } 1002 1003 } 1004 1005 TSourceToken lcnexttoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1006 if ((lcnexttoken != null)) { 1007 if (lcnexttoken.tokencode == TBaseType.rrw_sybase_partition) 1008 lcisnewsql = false; 1009 } 1010 1011 } 1012 1013 if (lcisnewsql) { 1014 ret = new TMergeSqlStatement(this.vendor); 1015 ret.sqlstatementtype = gnewsqlstatementtype; 1016 } 1017 1018 break; 1019 } 1020 case sstmssqlbegintry: 1021 case sstmssqlbegincatch: { 1022 ret = new TMssqlBlock(this.vendor); 1023 ret.sqlstatementtype = gnewsqlstatementtype; 1024 break; 1025 } 1026 case sstmssqlexec: { 1027 lcisnewsql = true; 1028 // prev tokentext can't be with 1029 if (pstate != EFindSqlStateType.stnormal) { 1030 if (TBaseType.assigned(lccurrentsqlstatement)) { 1031 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 1032 if (lccurrentsqlstatement.dummytag == 1) { 1033 lcisnewsql = false; 1034 lccurrentsqlstatement.dummytag = 0; // no select is permited after it 1035 } 1036 } 1037 1038 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 1039 if (TBaseType.assigned(lcprevsolidtoken)) { 1040 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 1041 lcisnewsql = false; 1042 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1043 lcisnewsql = false; 1044 } 1045 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlrevoke) { 1046 if (TBaseType.assigned(lcprevsolidtoken)) { 1047 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 1048 lcisnewsql = false; 1049 } 1050 } 1051 1052 1053 if ( 1054 (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateprocedure) 1055 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) 1056 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatefunction) 1057 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) 1058 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) 1059 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterfunction) 1060 ) { 1061 if (TBaseType.assigned(lcprevsolidtoken)) { 1062 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) 1063 lcisnewsql = false; 1064 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1065 lcisnewsql = false; 1066 } 1067 } 1068 } 1069 } 1070 if (lcisnewsql) { 1071 ret = new TMssqlExecute(this.vendor); 1072 } 1073 break; 1074 } 1075 case sstmssqlexecuteas: { 1076 lcisnewsql = true; 1077 // prev tokentext can't be with 1078 if (pstate != EFindSqlStateType.stnormal) { 1079 if (TBaseType.assigned(lccurrentsqlstatement)) { 1080 if ( 1081 (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateprocedure) 1082 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) 1083 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatefunction) 1084 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) 1085 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) 1086 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterfunction) 1087 ) { 1088 if (TBaseType.assigned(lcprevsolidtoken)) { 1089 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) 1090 lcisnewsql = false; 1091 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1092 lcisnewsql = false; 1093 } 1094 } 1095 } 1096 } 1097 if (lcisnewsql) { 1098 ret = new TMssqlExecuteAs(this.vendor); 1099 ret.sqlstatementtype = gnewsqlstatementtype; 1100 } 1101 break; 1102 } 1103 case sstmssqlset: { 1104 lcisnewsql = true; 1105 if (pstate != EFindSqlStateType.stnormal) { 1106 if (TBaseType.assigned(lccurrentsqlstatement)) { 1107 1108 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif) { 1109 TSourceToken lcPPToken = lcsourcetokenlist.searchToken(TBaseType.rrw_update, "", pcst, -10); 1110 if (TBaseType.assigned(lcPPToken)) { 1111 lcisnewsql = false; 1112 } 1113 } 1114 1115 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 1116 if (lcprevsolidtoken != null) { 1117 if (lcprevsolidtoken.tokencode == TBaseType.rrw_update) { 1118 lcisnewsql = false; 1119 } 1120 } 1121 } 1122 1123 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstupdate) { 1124 if (lccurrentsqlstatement.dummytag == 1) { 1125 //update statement still find set clause yet, so this is setclause in update statement 1126 lccurrentsqlstatement.dummytag = 0; 1127 lcisnewsql = false; 1128 } 1129 } 1130 } 1131 1132 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1133 if (TBaseType.assigned(lcnextsolidtoken)) { //set null, set default 1134 if ((TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "null") == 0) 1135 || (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "default") == 0)) { 1136 lcisnewsql = false; 1137 } 1138 } 1139 1140 } 1141 1142 if (lcisnewsql) { 1143 ret = new TMssqlSet(this.vendor); 1144 } 1145 1146 break; 1147 } 1148 case sstmssqlupdatetext: { 1149 ret = new TMssqlUpdateText(this.vendor); 1150 break; 1151 } 1152 case sstmssqlendconversation: { 1153 ret = new TMssqlEndConversation(this.vendor); 1154 break; 1155 } 1156 case sstmssqlbegindialog: { 1157 ret = new TMssqlBeginDialog(this.vendor); 1158 break; 1159 } 1160 case sstmssqlsendonconversation: { 1161 ret = new TMssqlSendOnConversation(this.vendor); 1162 break; 1163 } 1164 case sstmssqldisabletrigger: 1165 case sstmssqlenabletrigger: { 1166 lcisnewsql = true; 1167 if (TBaseType.assigned(lccurrentsqlstatement)) { 1168 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) 1169 lcisnewsql = false; 1170 } 1171 1172 if (lcisnewsql) { 1173 ret = new TDisableEnableTriggerStmt(this.vendor); 1174 ret.sqlstatementtype = gnewsqlstatementtype; 1175 } 1176 break; 1177 } 1178 case sstsybaseWritetext: { 1179 ret = new TSybaseWritetext(this.vendor); 1180 break; 1181 } 1182 case sstsybaseDeleteStatistics: { 1183 ret = new TSybaseDeleteStatistics(this.vendor); 1184 break; 1185 } 1186 case sstcall: { 1187 ret = new TCallStatement(this.vendor); 1188 break; 1189 } 1190 default: { 1191 ret = new TUnknownSqlStatement(this.vendor); 1192 ret.sqlstatementtype = gnewsqlstatementtype; 1193 break; 1194 } 1195 } // case 1196 1197 return ret; 1198 } 1199}