001package gudusoft.gsqlparser.sqlcmds; 002 003import gudusoft.gsqlparser.*; 004import gudusoft.gsqlparser.stmt.*; 005import gudusoft.gsqlparser.stmt.mssql.*; 006import gudusoft.gsqlparser.stmt.snowflake.*; 007 008/** 009 * Microsoft SQL Server-specific SQL command resolver. 010 * Handles T-SQL statement recognition. 011 * 012 * @since 3.1.0.9 013 */ 014public class TSqlCmdsMssql extends AbstractSqlCmds { 015 016 public TSqlCmdsMssql() { 017 super(EDbVendor.dbvmssql); 018 } 019 020 021 /** 022 * this method is used to set the vendor. 023 * this method is used temporarily due to ODBC use the TSqlCmdsMssql 024 * @param dbVendor 025 */ 026 public void setVendor(EDbVendor dbVendor){ 027 vendor = dbVendor; 028 } 029 030 @Override 031 protected String getToken1Str(int token1) { 032 // Handle MSSQL-specific reserved words (token codes > TBaseType.rrw_abort) 033 switch (token1) { 034 case TBaseType.rrw_sqlserver_throw: 035 return "throw"; 036 default: 037 return null; 038 } 039 } 040 041 @Override 042 protected void initializeCommands() { 043 // MSSQL commands must be sorted alphabetically by token1 044 045 // ADD commands 046 addCmd(TBaseType.rrw_add, "counter", "signature", ESqlStatementType.sstmssqladdsignature); 047 addCmd(TBaseType.rrw_add, "signature", ESqlStatementType.sstmssqladdsignature); 048 049 // ALTER commands 050 addCmd(TBaseType.rrw_alter, "application", "role", ESqlStatementType.sstmssqlalterapplicationrole); 051 addCmd(TBaseType.rrw_alter, "assembly", ESqlStatementType.sstmssqlalterassembly); 052 addCmd(TBaseType.rrw_alter, "asymmetric", "key", ESqlStatementType.sstmssqlalterasymmetrickey); 053 addCmd(TBaseType.rrw_alter, "authorization", ESqlStatementType.sstmssqlalterauthorization); 054 addCmd(TBaseType.rrw_alter, "certificate", ESqlStatementType.sstmssqlaltercertificate); 055 addCmd(TBaseType.rrw_alter, "credential", ESqlStatementType.sstmssqlaltercredential); 056 addCmd(TBaseType.rrw_alter, "database", ESqlStatementType.sstmssqlalterdatabase); 057 addCmd(TBaseType.rrw_alter, "endpoint", ESqlStatementType.sstmssqlalterendpoint); 058 addCmd(TBaseType.rrw_alter, "fulltext", "catalog", ESqlStatementType.sstmssqlalterfulltextcatalog); 059 addCmd(TBaseType.rrw_alter, "fulltext", "index", ESqlStatementType.sstmssqlalterfulltextindex); 060 addCmd(TBaseType.rrw_alter, "function", ESqlStatementType.sstmssqlalterfunction); 061 addCmd(TBaseType.rrw_alter, "index", ESqlStatementType.sstmssqlalterindex); 062 addCmd(TBaseType.rrw_alter, "login", ESqlStatementType.sstmssqlalterlogin); 063 addCmd(TBaseType.rrw_alter, "master", "key", ESqlStatementType.sstmssqlaltermasterkey); 064 addCmd(TBaseType.rrw_alter, "message", "type", ESqlStatementType.sstmssqlaltermessagetype); 065 addCmd(TBaseType.rrw_alter, "partition", "function", ESqlStatementType.sstmssqlalterpartitionfunction); 066 addCmd(TBaseType.rrw_alter, "partition", "scheme", ESqlStatementType.sstmssqlalterpartitionscheme); 067 addCmd(TBaseType.rrw_alter, "proc", ESqlStatementType.sstmssqlalterprocedure); 068 addCmd(TBaseType.rrw_alter, "procedure", ESqlStatementType.sstmssqlalterprocedure); 069 addCmd(TBaseType.rrw_alter, "queue", ESqlStatementType.sstmssqlalterqueue); 070 addCmd(TBaseType.rrw_alter, "remote", "service", "binding", ESqlStatementType.sstmssqlalterremoteservicebinding); 071 addCmd(TBaseType.rrw_alter, "role", ESqlStatementType.sstmssqlalterrole); 072 addCmd(TBaseType.rrw_alter, "route", ESqlStatementType.sstmssqlalterroute); 073 addCmd(TBaseType.rrw_alter, "schema", ESqlStatementType.sstmssqlalterschema); 074 addCmd(TBaseType.rrw_alter, "security", "policy", ESqlStatementType.sstmssqlAlterSecurityPolicy); 075 addCmd(TBaseType.rrw_alter, "sequence", ESqlStatementType.sstaltersequence); 076 addCmd(TBaseType.rrw_alter, "service", ESqlStatementType.sstmssqlalterservice); 077 addCmd(TBaseType.rrw_alter, "service", "master", "key", ESqlStatementType.sstmssqlalterservicemasterkey); 078 addCmd(TBaseType.rrw_alter, "symmetric", "key", ESqlStatementType.sstmssqlaltersymmetrickey); 079 addCmd(TBaseType.rrw_alter, "table", ESqlStatementType.sstaltertable); 080 addCmd(TBaseType.rrw_alter, "trigger", ESqlStatementType.sstmssqlaltertrigger); 081 addCmd(TBaseType.rrw_alter, "user", ESqlStatementType.sstmssqlalteruser); 082 addCmd(TBaseType.rrw_alter, "view", ESqlStatementType.sstmssqlalterview); 083 addCmd(TBaseType.rrw_alter, "xml", "schema", "collection", ESqlStatementType.sstmssqlalterxmlschemacollection); 084 085 // BACKUP commands 086 addCmd(TBaseType.rrw_backup, "certificate", ESqlStatementType.sstmssqlbackupcertificate); 087 addCmd(TBaseType.rrw_backup, "database", ESqlStatementType.sstmssqlbackupdatabase); 088 addCmd(TBaseType.rrw_backup, "log", ESqlStatementType.sstmssqlbackuplog); 089 addCmd(TBaseType.rrw_backup, "master", "key", ESqlStatementType.sstmssqlbackupmasterkey); 090 addCmd(TBaseType.rrw_backup, "service", "master", "key", ESqlStatementType.sstmssqlbackupservicemasterkey); 091 092 // BEGIN commands 093 addCmd(TBaseType.rrw_begin, "catch", ESqlStatementType.sstmssqlbegincatch); 094 addCmd(TBaseType.rrw_begin, "conversation", "timer", ESqlStatementType.sstmssqlbeginconversationtimer); 095 addCmd(TBaseType.rrw_begin, "dialog", ESqlStatementType.sstmssqlbegindialog); 096 addCmd(TBaseType.rrw_begin, "distributed", ESqlStatementType.sstmssqlbegindistributed); 097 addCmd(TBaseType.rrw_begin, "tran", ESqlStatementType.sstmssqlbegintran); 098 addCmd(TBaseType.rrw_begin, "transaction", ESqlStatementType.sstmssqlbegintran); 099 addCmd(TBaseType.rrw_begin, "try", ESqlStatementType.sstmssqlbegintry); 100 101 // BREAK 102 addCmd(TBaseType.rrw_break, ESqlStatementType.sstbreak); 103 104 // BULK INSERT 105 addCmd(TBaseType.rrw_bulk, "insert", ESqlStatementType.sstmssqlbulkinsert); 106 107 // CHECKPOINT 108 addCmd(TBaseType.rrw_checkpoint, ESqlStatementType.sstmssqlcheckpoint); 109 110 // CLOSE commands 111 addCmd(TBaseType.rrw_close, ESqlStatementType.sstmssqlclose); 112 addCmd(TBaseType.rrw_close, "all", "symmetric", "keys", ESqlStatementType.sstmssqlclosesymmetrickey); 113 addCmd(TBaseType.rrw_close, "master", "key", ESqlStatementType.sstmssqlclosemasterkey); 114 addCmd(TBaseType.rrw_close, "symmetric", "key", ESqlStatementType.sstmssqlclosesymmetrickey); 115 116 // COMMIT commands 117 addCmd(TBaseType.rrw_commit, ESqlStatementType.sstmssqlcommit); 118 addCmd(TBaseType.rrw_commit, "work", ESqlStatementType.sstmssqlcommit); 119 addCmd(TBaseType.rrw_commit, "tran", ESqlStatementType.sstmssqlcommit); 120 addCmd(TBaseType.rrw_commit, "transaction", ESqlStatementType.sstmssqlcommit); 121 122 // CONTINUE 123 addCmd(TBaseType.rrw_continue, ESqlStatementType.sstmssqlcontinue); 124 125 // COPY INTO 126 addCmd(TBaseType.rrw_sqlserver_copyinto, "into", ESqlStatementType.sstCopyInto); 127 128 // CREATE commands 129 addCmd(TBaseType.rrw_create, "aggregate", ESqlStatementType.sstmssqlcreateaggregate); 130 addCmd(TBaseType.rrw_create, "application", "role", ESqlStatementType.sstmssqlcreateapplicationrole); 131 addCmd(TBaseType.rrw_create, "assembly", ESqlStatementType.sstmssqlcreateassembly); 132 addCmd(TBaseType.rrw_create, "asymmetric", "key", ESqlStatementType.sstmssqlcreateasymmetrickey); 133 addCmd(TBaseType.rrw_create, "certificate", ESqlStatementType.sstmssqlcreatecertificate); 134 addCmd(TBaseType.rrw_create, "clustered", "columnstore", "index", ESqlStatementType.sstcreateindex); 135 addCmd(TBaseType.rrw_create, "clustered", "index", ESqlStatementType.sstcreateindex); 136 addCmd(TBaseType.rrw_create, "columnstore", "index", ESqlStatementType.sstcreateindex); 137 addCmd(TBaseType.rrw_create, "contract", ESqlStatementType.sstmssqlcreatecontract); 138 addCmd(TBaseType.rrw_create, "credential", ESqlStatementType.sstcreatecredential); 139 addCmd(TBaseType.rrw_create, "database", "scoped", "credential", ESqlStatementType.sstcreatecredential); 140 addCmd(TBaseType.rrw_create, "database", ESqlStatementType.sstcreatedatabase); 141 addCmd(TBaseType.rrw_create, "default", ESqlStatementType.sstmssqlcreatedefault); 142 addCmd(TBaseType.rrw_create, "endpoint", ESqlStatementType.sstmssqlcreateendpoint); 143 addCmd(TBaseType.rrw_create, "event", "notification", ESqlStatementType.sstmssqlcreateeventnotification); 144 addCmd(TBaseType.rrw_create, "event", "session", ESqlStatementType.sstmssqlcreateeventsession); 145 addCmd(TBaseType.rrw_create, "external", "data", "source", ESqlStatementType.sstmssqlcreateevexternalDataSource); 146 addCmd(TBaseType.rrw_create, "external", "file", "format", ESqlStatementType.sstCreateFileFormat); 147 addCmd(TBaseType.rrw_create, "external", "language", ESqlStatementType.sstmssqlcreateevexternalLanguage); 148 addCmd(TBaseType.rrw_create, "external", "table", ESqlStatementType.sstcreatetable); 149 addCmd(TBaseType.rrw_create, "fulltext", "catalog", ESqlStatementType.sstmssqlcreatefulltextcatalog); 150 addCmd(TBaseType.rrw_create, "fulltext", "index", ESqlStatementType.sstmssqlcreatefulltextindex); 151 addCmd(TBaseType.rrw_create, "function", ESqlStatementType.sstmssqlcreatefunction); 152 addCmd(TBaseType.rrw_create, "index", ESqlStatementType.sstcreateindex); 153 addCmd(TBaseType.rrw_create, "login", ESqlStatementType.sstmssqlcreatelogin); 154 addCmd(TBaseType.rrw_create, "master", "key", ESqlStatementType.sstmssqlcreatemasterkey); 155 addCmd(TBaseType.rrw_create, "materialized", "view", ESqlStatementType.sstcreatematerializedview); 156 addCmd(TBaseType.rrw_create, "message", "type", ESqlStatementType.sstmssqlcreatemessagetype); 157 addCmd(TBaseType.rrw_create, "nonclustered", "columnstore", "index", ESqlStatementType.sstcreateindex); 158 addCmd(TBaseType.rrw_create, "nonclustered", "index", ESqlStatementType.sstcreateindex); 159 addCmd(TBaseType.rrw_create, "or", "alter", "function", ESqlStatementType.sstmssqlcreatefunction); 160 addCmd(TBaseType.rrw_create, "or", "alter", "proc", ESqlStatementType.sstmssqlcreateprocedure); 161 addCmd(TBaseType.rrw_create, "or", "alter", "procedure", ESqlStatementType.sstmssqlcreateprocedure); 162 addCmd(TBaseType.rrw_create, "or", "alter", "view", ESqlStatementType.sstcreateview); 163 addCmd(TBaseType.rrw_create, "partition", "function", ESqlStatementType.sstmssqlcreatepartitionfunction); 164 addCmd(TBaseType.rrw_create, "partition", "scheme", ESqlStatementType.sstmssqlcreatepartitionscheme); 165 addCmd(TBaseType.rrw_create, "primary", "xml", "index", ESqlStatementType.sstcreateindex); 166 addCmd(TBaseType.rrw_create, "proc", ESqlStatementType.sstmssqlcreateprocedure); 167 addCmd(TBaseType.rrw_create, "procedure", ESqlStatementType.sstmssqlcreateprocedure); 168 addCmd(TBaseType.rrw_create, "queue", ESqlStatementType.sstmssqlcreatequeue); 169 addCmd(TBaseType.rrw_create, "remote", "service", "binding", ESqlStatementType.sstmssqlcreateremoteservicebinding); 170 addCmd(TBaseType.rrw_create, "role", ESqlStatementType.sstmssqlcreaterole); 171 addCmd(TBaseType.rrw_create, "route", ESqlStatementType.sstmssqlcreateroute); 172 addCmd(TBaseType.rrw_create, "rule", ESqlStatementType.sstmssqlcreaterule); 173 addCmd(TBaseType.rrw_create, "schema", ESqlStatementType.sstmssqlcreateschema); 174 addCmd(TBaseType.rrw_create, "security", "policy", ESqlStatementType.sstmssqlCreateSecurityPolicy); 175 addCmd(TBaseType.rrw_create, "sequence", ESqlStatementType.sstcreatesequence); 176 addCmd(TBaseType.rrw_create, "service", ESqlStatementType.sstmssqlcreateservice); 177 addCmd(TBaseType.rrw_create, "statistics", ESqlStatementType.sstmssqlcreatestatistics); 178 addCmd(TBaseType.rrw_create, "symmetric", "key", ESqlStatementType.sstmssqlcreatesymmetrickey); 179 addCmd(TBaseType.rrw_create, "synonym", ESqlStatementType.sstmssqlcreatesynonym); 180 addCmd(TBaseType.rrw_create, "table", ESqlStatementType.sstcreatetable); 181 addCmd(TBaseType.rrw_create, "trigger", ESqlStatementType.sstcreatetrigger); 182 addCmd(TBaseType.rrw_create, "type", ESqlStatementType.sstmssqlcreatetype); 183 addCmd(TBaseType.rrw_create, "unique", "clustered", "index", ESqlStatementType.sstcreateindex); 184 addCmd(TBaseType.rrw_create, "unique", "index", ESqlStatementType.sstcreateindex); 185 addCmd(TBaseType.rrw_create, "unique", "nonclustered", "index", ESqlStatementType.sstcreateindex); 186 addCmd(TBaseType.rrw_create, "user", ESqlStatementType.sstmssqlcreateuser); 187 addCmd(TBaseType.rrw_create, "view", ESqlStatementType.sstcreateview); 188 addCmd(TBaseType.rrw_create, "xml", "index", ESqlStatementType.sstcreateindex); 189 addCmd(TBaseType.rrw_create, "xml", "schema", "collection", ESqlStatementType.sstmssqlcreatexmlschemacollection); 190 191 // DBCC 192 addCmd(TBaseType.rrw_dbcc, ESqlStatementType.sstmssqldbcc); 193 194 // DEALLOCATE 195 addCmd(TBaseType.rrw_deallocate, ESqlStatementType.sstmssqldeallocate); 196 197 // DECLARE 198 addCmd(TBaseType.rrw_declare, ESqlStatementType.sstmssqldeclare); 199 200 // DELETE 201 addCmd(TBaseType.rrw_delete, ESqlStatementType.sstdelete); 202 203 // DENY 204 addCmd(TBaseType.rrw_deny, ESqlStatementType.sstmssqldeny); 205 206 // DISABLE TRIGGER 207 addCmd(TBaseType.rrw_disable, "trigger", ESqlStatementType.sstmssqldisabletrigger); 208 209 // DROP commands 210 addCmd(TBaseType.rrw_drop, "aggregate", ESqlStatementType.sstmssqldropaggregate); 211 addCmd(TBaseType.rrw_drop, "application", "role", ESqlStatementType.sstmssqldropapplicationrole); 212 addCmd(TBaseType.rrw_drop, "assembly", ESqlStatementType.sstmssqldropassembly); 213 addCmd(TBaseType.rrw_drop, "asymmetric", "key", ESqlStatementType.sstmssqldropasymmetrickey); 214 addCmd(TBaseType.rrw_drop, "certificate", ESqlStatementType.sstmssqldropcertificate); 215 addCmd(TBaseType.rrw_drop, "contract", ESqlStatementType.sstmssqldropcontract); 216 addCmd(TBaseType.rrw_drop, "counter", "signature", ESqlStatementType.sstmssqldropsignature); 217 addCmd(TBaseType.rrw_drop, "credential", ESqlStatementType.sstmssqldropcredential); 218 addCmd(TBaseType.rrw_drop, "database", ESqlStatementType.sstmssqldropdatabase); 219 addCmd(TBaseType.rrw_drop, "default", ESqlStatementType.sstmssqldropdefault); 220 addCmd(TBaseType.rrw_drop, "endpoint", ESqlStatementType.sstmssqldropendpoint); 221 addCmd(TBaseType.rrw_drop, "event", "notification", ESqlStatementType.sstmssqldropeventnotification); 222 addCmd(TBaseType.rrw_drop, "event", "session", ESqlStatementType.sstmssqldropeventsession); 223 addCmd(TBaseType.rrw_drop, "fulltext", "catalog", ESqlStatementType.sstmssqldropfulltextcatalog); 224 addCmd(TBaseType.rrw_drop, "fulltext", "index", ESqlStatementType.sstmssqldropfulltextindex); 225 addCmd(TBaseType.rrw_drop, "function", ESqlStatementType.sstmssqldropfunction); 226 addCmd(TBaseType.rrw_drop, "index", ESqlStatementType.sstmssqldropindex); 227 addCmd(TBaseType.rrw_drop, "login", ESqlStatementType.sstmssqldroplogin); 228 addCmd(TBaseType.rrw_drop, "master", "key", ESqlStatementType.sstmssqldropmasterkey); 229 addCmd(TBaseType.rrw_drop, "message", "type", ESqlStatementType.sstmssqldropmessagetype); 230 addCmd(TBaseType.rrw_drop, "partition", "function", ESqlStatementType.sstmssqldroppartitionfunction); 231 addCmd(TBaseType.rrw_drop, "partition", "scheme", ESqlStatementType.sstmssqldroppartitionscheme); 232 addCmd(TBaseType.rrw_drop, "proc", ESqlStatementType.sstmssqldropprocedure); 233 addCmd(TBaseType.rrw_drop, "procedure", ESqlStatementType.sstmssqldropprocedure); 234 addCmd(TBaseType.rrw_drop, "queue", ESqlStatementType.sstmssqldropqueue); 235 addCmd(TBaseType.rrw_drop, "remote", "service", "binding", ESqlStatementType.sstmssqldropremoteservicebinding); 236 addCmd(TBaseType.rrw_drop, "role", ESqlStatementType.sstmssqldroprole); 237 addCmd(TBaseType.rrw_drop, "route", ESqlStatementType.sstmssqldroproute); 238 addCmd(TBaseType.rrw_drop, "rule", ESqlStatementType.sstmssqldroprule); 239 addCmd(TBaseType.rrw_drop, "schema", ESqlStatementType.sstmssqldropschema); 240 addCmd(TBaseType.rrw_drop, "security", "policy", ESqlStatementType.sstmssqlDropSecurityPolicy); 241 addCmd(TBaseType.rrw_drop, "sequence", ESqlStatementType.sstdropsequence); 242 addCmd(TBaseType.rrw_drop, "service", ESqlStatementType.sstmssqldropservice); 243 addCmd(TBaseType.rrw_drop, "signature", ESqlStatementType.sstmssqldropsignature); 244 addCmd(TBaseType.rrw_drop, "statistics", ESqlStatementType.sstmssqldropstatistics); 245 addCmd(TBaseType.rrw_drop, "symmetric", "key", ESqlStatementType.sstmssqldropsymmetrickey); 246 addCmd(TBaseType.rrw_drop, "synonym", ESqlStatementType.sstmssqldropsynonym); 247 addCmd(TBaseType.rrw_drop, "table", ESqlStatementType.sstmssqldroptable); 248 addCmd(TBaseType.rrw_drop, "trigger", ESqlStatementType.sstmssqldroptrigger); 249 addCmd(TBaseType.rrw_drop, "type", ESqlStatementType.sstmssqldroptype); 250 addCmd(TBaseType.rrw_drop, "user", ESqlStatementType.sstmssqldropuser); 251 addCmd(TBaseType.rrw_drop, "view", ESqlStatementType.sstmssqldropview); 252 addCmd(TBaseType.rrw_drop, "xml", "schema", "collection", ESqlStatementType.sstmssqldropxmlschemacollection); 253 254 // ENABLE TRIGGER 255 addCmd(TBaseType.rrw_enable, "trigger", ESqlStatementType.sstmssqlenabletrigger); 256 257 // END CONVERSATION 258 addCmd(TBaseType.rrw_end, "conversation", ESqlStatementType.sstmssqlendconversation); 259 260 // EXEC/EXECUTE commands 261 addCmd(TBaseType.rrw_exec, ESqlStatementType.sstmssqlexec); 262 addCmd(TBaseType.rrw_exec, "as", "caller", ESqlStatementType.sstmssqlexecuteas); 263 addCmd(TBaseType.rrw_exec, "as", "login", ESqlStatementType.sstmssqlexecuteas); 264 addCmd(TBaseType.rrw_exec, "as", "user", ESqlStatementType.sstmssqlexecuteas); 265 addCmd(TBaseType.rrw_execute, ESqlStatementType.sstmssqlexec); 266 addCmd(TBaseType.rrw_execute, "as", "caller", ESqlStatementType.sstmssqlexecuteas); 267 addCmd(TBaseType.rrw_execute, "as", "login", ESqlStatementType.sstmssqlexecuteas); 268 addCmd(TBaseType.rrw_execute, "as", "user", ESqlStatementType.sstmssqlexecuteas); 269 270 // FETCH 271 addCmd(TBaseType.rrw_fetch, ESqlStatementType.sstmssqlfetch); 272 273 // GO 274 addCmd(TBaseType.rrw_go, ESqlStatementType.sstmssqlgo); 275 276 // GOTO 277 addCmd(TBaseType.rrw_goto, ESqlStatementType.sstmssqlgoto); 278 279 // GRANT 280 addCmd(TBaseType.rrw_grant, ESqlStatementType.sstmssqlgrant); 281 282 // IF 283 addCmd(TBaseType.rrw_if, ESqlStatementType.sstmssqlif); 284 285 // INSERT 286 addCmd(TBaseType.rrw_insert, ESqlStatementType.sstinsert); 287 addCmd(TBaseType.rrw_insert, "bulk", ESqlStatementType.sstmssqlinsertbulk); 288 289 // KILL commands 290 addCmd(TBaseType.rrw_kill, ESqlStatementType.sstmssqlkill); 291 addCmd(TBaseType.rrw_kill, "kill", "query", "notification", "subscription", ESqlStatementType.sstmssqlkillquerynotificationsubscription); 292 addCmd(TBaseType.rrw_kill, "stats", ESqlStatementType.sstmssqlkillstats); 293 294 // LOCK TABLE 295 addCmd(TBaseType.rw_locktable, "table", ESqlStatementType.sstsybaselocktable); 296 297 // MOVE CONVERSATION 298 addCmd(TBaseType.rrw_move, "conversation", ESqlStatementType.sstmssqlmoveconversation); 299 300 // MERGE 301 addCmd(TBaseType.rrw_merge, ESqlStatementType.sstmerge); 302 303 // OPEN commands 304 addCmd(TBaseType.rrw_open, ESqlStatementType.sstmssqlopen); 305 addCmd(TBaseType.rrw_open, "master", "key", ESqlStatementType.sstmssqlopenmasterkey); 306 addCmd(TBaseType.rrw_open, "symmetric", "key", ESqlStatementType.sstmssqlopensymmetrickey); 307 308 // PRINT 309 addCmd(TBaseType.rrw_print, ESqlStatementType.sstmssqlprint); 310 311 // RAISERROR 312 addCmd(TBaseType.rrw_raiserror, ESqlStatementType.sstmssqlraiserror); 313 314 // READTEXT 315 addCmd(TBaseType.rrw_readtext, ESqlStatementType.sstmssqlreadtext); 316 317 // RECEIVE 318 addCmd(TBaseType.rrw_receive, ESqlStatementType.sstmssqlreceive); 319 320 // RECONFIGURE 321 addCmd(TBaseType.rrw_reconfigure, ESqlStatementType.sstmssqlreconfigure); 322 323 // RESTORE commands 324 addCmd(TBaseType.rrw_restore, "database", ESqlStatementType.sstmssqlrestoredatabase); 325 addCmd(TBaseType.rrw_restore, "filelistonly", ESqlStatementType.sstmssqlrestorefilelistonly); 326 addCmd(TBaseType.rrw_restore, "headeronly", ESqlStatementType.sstmssqlrestoreheaderonly); 327 addCmd(TBaseType.rrw_restore, "labelonly", ESqlStatementType.sstmssqlrestorelabelonly); 328 addCmd(TBaseType.rrw_restore, "log", ESqlStatementType.sstmssqlrestorelog); 329 addCmd(TBaseType.rrw_restore, "master", "key", ESqlStatementType.sstmssqlrestoremasterkey); 330 addCmd(TBaseType.rrw_restore, "rewindonly", ESqlStatementType.sstmssqlrestorerewindonly); 331 addCmd(TBaseType.rrw_restore, "service", "master", "key", ESqlStatementType.sstmssqlrestoreservicemasterkey); 332 addCmd(TBaseType.rrw_restore, "verifyonly", ESqlStatementType.sstmssqlrestoreverifyonly); 333 334 // RETURN 335 addCmd(TBaseType.rrw_return, ESqlStatementType.sstmssqlreturn); 336 337 // REVERT 338 addCmd(TBaseType.rrw_revert, ESqlStatementType.sstmssqlrevert); 339 340 // REVOKE 341 addCmd(TBaseType.rrw_revoke, ESqlStatementType.sstmssqlrevoke); 342 343 // ROLLBACK commands 344 addCmd(TBaseType.rrw_rollback, ESqlStatementType.sstmssqlrollback); 345 addCmd(TBaseType.rrw_rollback, "tran", ESqlStatementType.sstmssqlrollback); 346 addCmd(TBaseType.rrw_rollback, "transaction", ESqlStatementType.sstmssqlrollback); 347 addCmd(TBaseType.rrw_rollback, "work", ESqlStatementType.sstmssqlrollback); 348 349 // SAVE commands 350 addCmd(TBaseType.rrw_save, ESqlStatementType.sstmssqlsavetran); 351 addCmd(TBaseType.rrw_save, "tran", ESqlStatementType.sstmssqlsavetran); 352 addCmd(TBaseType.rrw_save, "transaction", ESqlStatementType.sstmssqlsavetran); 353 354 // SELECT 355 addCmd(TBaseType.rrw_select, ESqlStatementType.sstselect); 356 357 // SEND ON CONVERSATION 358 addCmd(TBaseType.rrw_send, "on", "conversation", ESqlStatementType.sstmssqlsendonconversation); 359 360 // SET commands 361 addCmd(TBaseType.rrw_set, ESqlStatementType.sstmssqlset); 362 addCmd(TBaseType.rrw_set, "rowcount", ESqlStatementType.sstmssqlsetrowcount); 363 364 // SETUSER 365 addCmd(TBaseType.rrw_setuser, ESqlStatementType.sstmssqlsetuser); 366 367 // SHUTDOWN 368 addCmd(TBaseType.rrw_shutdown, ESqlStatementType.sstmssqlshutdown); 369 370 // THROW 371 addCmd(TBaseType.rrw_sqlserver_throw, ESqlStatementType.sstmssqlthrow); 372 373 // TRUNCATE TABLE 374 addCmd(TBaseType.rrw_truncate, "table", ESqlStatementType.sstmssqltruncatetable); 375 376 // UPDATE commands 377 addCmd(TBaseType.rrw_update, ESqlStatementType.sstupdate); 378 addCmd(TBaseType.rrw_update, "statistics", ESqlStatementType.sstmssqlupdatestatistics); 379 380 // UPDATETEXT 381 addCmd(TBaseType.rrw_updatetext, ESqlStatementType.sstmssqlupdatetext); 382 383 // USE 384 addCmd(TBaseType.rrw_use, ESqlStatementType.sstmssqluse); 385 386 // WAITFOR 387 addCmd(TBaseType.rrw_waitfor, ESqlStatementType.sstmssqlwaitfor); 388 389 // WHILE 390 addCmd(TBaseType.rrw_while, ESqlStatementType.sstmssqlwhile); 391 392 // WRITETEXT 393 addCmd(TBaseType.rrw_writetext, ESqlStatementType.sstmssqlwritetext); 394 } 395 396 @Override 397 public ESqlStatementType getStatementTypeForToken(TSourceToken token) { 398 ESqlStatementType ret = ESqlStatementType.sstinvalid; 399 400 int lcpos = token.posinlist; 401 TSourceTokenList lcsourcetokenlist = token.container; 402 403 // Subquery after semicolon or at first line 404 if (token.tokentype == ETokenType.ttleftparenthesis) { // ( 405 int k = lcsourcetokenlist.solidtokenafterpos(lcpos, TBaseType.rrw_select, 1, "("); 406 if (k > 0) { 407 ret = ESqlStatementType.sstselect; 408 } 409 return ret; 410 } 411 412 ret = super.getStatementTypeForToken (token); 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 token, EFindSqlStateType state, TCustomSqlStatement currentStatement) { 423 TCustomSqlStatement ret = null; 424 int k; 425 boolean lcisnewsql; 426 TSourceToken lcpprevsolidtoken, lcnextsolidtoken, lctoken; 427 428 gnewsqlstatementtype = ESqlStatementType.sstinvalid; 429 430 if ((token.tokencode == TBaseType.cmtdoublehyphen) 431 || (token.tokencode == TBaseType.cmtslashstar) 432 || (token.tokencode == TBaseType.lexspace) 433 || (token.tokencode == TBaseType.lexnewline) 434 || (token.tokentype == ETokenType.ttsemicolon)) { 435 return ret; 436 } 437 438 int lcpos = token.posinlist; 439 TSourceTokenList lcsourcetokenlist = token.container; 440 TCustomSqlStatement lccurrentsqlstatement = currentStatement; 441 442 // Subquery after semicolon or at first line 443 if (token.tokentype == ETokenType.ttleftparenthesis) { // ( 444 k = lcsourcetokenlist.solidtokenafterpos(lcpos, TBaseType.rrw_select, 1, "("); 445 if (k > 0) { 446 if (state == EFindSqlStateType.stnormal) { 447 ret = new TSelectSqlStatement(vendor); 448 return ret; 449 } 450 } 451 } 452 453 // CTE 454 if ((state == EFindSqlStateType.stnormal) && (token.tokencode == TBaseType.rrw_with)) { 455 ret = findcte(token); 456 if ((ret != null)) return ret; 457 } 458 459 if ((lccurrentsqlstatement != null) && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 460 && (token.tokencode == TBaseType.rrw_with)) { 461 TSourceToken lcPrevToken = token.prevSolidToken(); 462 if ((lcPrevToken != null) && (lcPrevToken.tokencode == TBaseType.rrw_as)) { 463 // mantisbt/view.php?id=3900, create table with as select, ignore tokens from with to select 464 ret = findcte(token); 465 if ((ret != null)) { 466 ret = null; 467 } 468 } 469 } 470 471 // ODBC 472 if ((state == EFindSqlStateType.stnormal) && ((token.tokencode == '{') || (token.tokencode == TBaseType.odbc_esc_prefix)) && (token.getLinkToken() != null)) { 473 ret = new TCallStatement(vendor); 474 return ret; 475 } 476 477 gnewsqlstatementtype = super.getStatementTypeForToken(token); 478 479 TSourceToken lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 480 switch (gnewsqlstatementtype) { 481 case sstinvalid: { 482 if (token.tokencode == TBaseType.mslabel) { 483 ret = new TMssqlLabel(vendor); 484 } else 485 ret = null; 486 break; 487 } 488 case sstselect: { 489 lcisnewsql = true; 490 491 if (state != EFindSqlStateType.stnormal) { 492 if ((lcprevsolidtoken != null)) { 493 if (lcprevsolidtoken.tokentype == ETokenType.ttleftparenthesis) 494 lcisnewsql = false; // subquery 495 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_union) 496 lcisnewsql = false; 497 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_intersect) 498 lcisnewsql = false; 499 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_minus) 500 lcisnewsql = false; 501 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_except) 502 lcisnewsql = false; 503 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_return) 504 lcisnewsql = false; 505 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_as) { 506 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 507 lcisnewsql = false; 508 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 509 lcisnewsql = false; 510 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstalterview) 511 lcisnewsql = false; 512 } else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) { 513 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlset) 514 lcisnewsql = false; 515 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqldeclare) 516 lcisnewsql = false; 517 } 518 519 if (lcisnewsql && (lcprevsolidtoken.tokencode == TBaseType.rrw_all)) { 520 lcpprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcprevsolidtoken.posinlist); 521 if ((lcpprevsolidtoken != null)) { 522 if (lcpprevsolidtoken.tokencode == TBaseType.rrw_union) 523 lcisnewsql = false; 524 } 525 } 526 } 527 528 if ((lccurrentsqlstatement != null)) { 529 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 530 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 531 if ((lcprevsolidtoken != null)) { 532 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 533 lcisnewsql = false; 534 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 535 lcisnewsql = false; 536 } 537 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) { 538 lcisnewsql = false; 539 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatematerializedview) { 540 lcisnewsql = false; 541 } 542 } 543 } 544 545 if (lcisnewsql) 546 ret = new TSelectSqlStatement(vendor); 547 break; 548 } 549 case sstinsert: { 550 lcisnewsql = true; 551 if (state != EFindSqlStateType.stnormal) { 552 if ((lccurrentsqlstatement != null)) { 553 // merge 554 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 555 if (lcprevsolidtoken != null) { 556 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 557 lcisnewsql = false; 558 } 559 } 560 } 561 562 // bulk insert 563 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlbulkinsert) { 564 if ((lcprevsolidtoken != null)) { 565 if (lcprevsolidtoken.tokencode == TBaseType.rrw_bulk) 566 lcisnewsql = false; 567 } 568 } 569 570 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 571 if ((lcprevsolidtoken != null)) { 572 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 573 lcisnewsql = false; 574 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 575 lcisnewsql = false; 576 } 577 } 578 579 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 580 if ((lcprevsolidtoken != null)) { 581 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 582 lcisnewsql = false; 583 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 584 lcisnewsql = false; 585 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 586 lcisnewsql = false; 587 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 588 lcisnewsql = false; 589 } 590 } 591 } 592 } 593 594 if (lcisnewsql) { 595 ret = new TInsertSqlStatement(vendor); 596 ret.dummytag = 1; // select stmt in insert is permitted 597 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 598 if (lcsourcetokenlist.get(k).isnonsolidtoken()) continue; 599 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_values) break; 600 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_go) break; 601 if (lcsourcetokenlist.get(k).tokentype == ETokenType.ttsemicolon) break; 602 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_select) { 603 ret.dummytag = 0; 604 break; 605 } 606 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_execute) break; 607 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_exec) break; 608 } 609 if (k > lcsourcetokenlist.size() - 1) 610 k = lcsourcetokenlist.size() - 1; 611 612 for (int i = lcpos + 1; i <= k; i++) { 613 lcsourcetokenlist.get(i).tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 614 } 615 } 616 break; 617 } 618 case sstupdate: { 619 lcisnewsql = true; 620 if (state != EFindSqlStateType.stnormal) { 621 if ((lcprevsolidtoken != null)) { 622 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 623 lcisnewsql = false; 624 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 625 lcisnewsql = false; 626 } 627 628 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 629 if (TBaseType.assigned(lcnextsolidtoken)) { 630 if (lcnextsolidtoken.tokentype == ETokenType.ttleftparenthesis) { 631 k = lcsourcetokenlist.solidtokenafterpos(lcnextsolidtoken.posinlist, TBaseType.rrw_select, 1, "("); 632 if (k == 0) lcisnewsql = false; 633 } 634 } 635 636 if (TBaseType.assigned(lccurrentsqlstatement)) { 637 // merge 638 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 639 if (lcprevsolidtoken != null) { 640 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 641 lcisnewsql = false; 642 } 643 } 644 } 645 646 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 647 if (TBaseType.assigned(lcprevsolidtoken)) { 648 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 649 lcisnewsql = false; 650 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 651 lcisnewsql = false; 652 } 653 } 654 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 655 if (TBaseType.assigned(lcprevsolidtoken)) { 656 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 657 lcisnewsql = false; 658 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 659 lcisnewsql = false; 660 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 661 lcisnewsql = false; 662 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 663 lcisnewsql = false; 664 } 665 } 666 } 667 } 668 669 if (lcisnewsql) { 670 ret = new TUpdateSqlStatement(vendor); 671 ret.dummytag = 1; // means set clause in update is not found yet 672 } 673 break; 674 } 675 case sstdelete: { 676 lcisnewsql = true; 677 678 if (state != EFindSqlStateType.stnormal) { 679 lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 680 if (TBaseType.assigned(lcprevsolidtoken)) { 681 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 682 lcisnewsql = false; 683 } 684 685 if (TBaseType.assigned(lccurrentsqlstatement)) { 686 // merge 687 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 688 if (lcprevsolidtoken != null) { 689 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 690 lcisnewsql = false; 691 } 692 } 693 } 694 695 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 696 if (TBaseType.assigned(lcprevsolidtoken)) { 697 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 698 lcisnewsql = false; 699 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 700 lcisnewsql = false; 701 } 702 } 703 704 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 705 if (TBaseType.assigned(lcprevsolidtoken)) { 706 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 707 lcisnewsql = false; 708 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 709 lcisnewsql = false; 710 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 711 lcisnewsql = false; 712 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 713 lcisnewsql = false; 714 } 715 } 716 } 717 } 718 719 if (lcisnewsql) 720 ret = new TDeleteSqlStatement(vendor); 721 break; 722 } 723 case sstcreatetable: { 724 lcisnewsql = true; 725 if (state != EFindSqlStateType.stnormal) { 726 if (TBaseType.assigned(lccurrentsqlstatement)) { 727 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 728 lcisnewsql = false; 729 } 730 } 731 } 732 733 if (lcisnewsql) { 734 ret = new TCreateTableSqlStatement(vendor); 735 } 736 break; 737 } 738 case sstcreateview: { 739 lcisnewsql = true; 740 if (state != EFindSqlStateType.stnormal) { 741 if (TBaseType.assigned(lccurrentsqlstatement)) { 742 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 743 lcisnewsql = false; 744 } 745 } 746 } 747 if (lcisnewsql) { 748 ret = new TCreateViewSqlStatement(vendor); 749 } 750 break; 751 } 752 case sstcreatesequence: { 753 ret = new TCreateSequenceStmt(vendor); 754 break; 755 } 756 case sstaltertable: { 757 ret = new TAlterTableStatement(vendor); 758 break; 759 } 760 case sstmssqlfetch: { 761 ret = new TMssqlFetch(vendor); 762 break; 763 } 764 case sstmssqlif: { 765 lcisnewsql = true; 766 if (state != EFindSqlStateType.stnormal) { 767 if (TBaseType.assigned(lccurrentsqlstatement)) { 768 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropprocedure) 769 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropdatabase) 770 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropfunction) 771 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlDropSecurityPolicy)) { 772 lcisnewsql = false; 773 } else if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdroptable) 774 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropindex) 775 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 776 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropsynonym) 777 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropview) 778 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropsequence)) { 779 // DROP TABLE IF EXISTS T1; 780 TSourceToken st = lcsourcetokenlist.solidtokenbefore(lcpos); 781 if ((st.tokencode == TBaseType.rrw_table) || (st.tokencode == TBaseType.rrw_index) 782 || (st.tokencode == TBaseType.rrw_sqlserver_synonym) || (st.tokencode == TBaseType.rrw_view) 783 || (st.tokencode == TBaseType.rrw_sqlserver_sequence)) { 784 lcisnewsql = false; 785 } 786 } else if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable)) { 787 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 788 if (lcnextsolidtoken != null) { 789 if (lcnextsolidtoken.tokencode == TBaseType.rrw_sqlserver_exists) { 790 lcisnewsql = false; 791 } 792 } 793 } 794 } 795 } 796 797 if (lcisnewsql) { 798 ret = new TMssqlIfElse(vendor); 799 ret.dummytag = 1; // reduce to 0 while stmt find in 'if (condition stmt' || 'else stmt' 800 } 801 break; 802 } 803 case sstmssqlwhile: { 804 ret = new TMssqlIfElse(vendor); 805 ret.dummytag = 1; // reduce to 0 while stmt find in 'if (condition stmt' || 'else stmt' 806 break; 807 } 808 case sstmssqlcreateprocedure: 809 case sstmssqlalterprocedure: { 810 ret = new TMssqlCreateProcedure(vendor); 811 break; 812 } 813 case sstmssqlcreatefunction: 814 case sstmssqlalterfunction: { 815 ret = new TMssqlCreateFunction(vendor); 816 break; 817 } 818 case sstcreatetrigger: 819 case sstmssqlaltertrigger: { 820 ret = new TCreateTriggerStmt(vendor); 821 break; 822 } 823 case sstmssqlreturn: { 824 ret = new TMssqlReturn(vendor); 825 break; 826 } 827 case sstmssqlprint: { 828 if (vendor == EDbVendor.dbvodbc) { 829 } else if (vendor == EDbVendor.dbvmssql) { 830 ret = new TMssqlPrint(vendor); 831 } 832 break; 833 } 834 case sstmssqluse: { 835 ret = new TUseDatabase(vendor); 836 break; 837 } 838 case sstmssqlgo: { 839 ret = new TMssqlGo(vendor); 840 break; 841 } 842 case sstmssqlrevert: { 843 lcisnewsql = true; 844 // prev tokentext can't be with 845 if (state != EFindSqlStateType.stnormal) { 846 if (TBaseType.assigned(lcprevsolidtoken)) { 847 if (lcprevsolidtoken.toString().equalsIgnoreCase("no")) { 848 ret = null; 849 lcisnewsql = false; 850 } 851 } 852 } 853 if (lcisnewsql) { 854 ret = new TMssqlRevert(vendor); 855 } 856 break; 857 } 858 case sstmssqlgrant: { 859 lcisnewsql = true; 860 // prev tokentext can't be with 861 if (state != EFindSqlStateType.stnormal) { 862 if (TBaseType.assigned(lcprevsolidtoken)) { 863 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) { 864 ret = null; 865 lcisnewsql = false; 866 } 867 } 868 869 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 870 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 871 lcisnewsql = false; 872 } 873 } 874 } 875 if (lcisnewsql) { 876 ret = new TGrantStmt(vendor); 877 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 878 lctoken = lcsourcetokenlist.get(k); 879 if (lctoken.isnonsolidtoken()) continue; 880 if (lctoken.tokencode == TBaseType.rrw_go) break; 881 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 882 if (lctoken.tokencode == TBaseType.rrw_to) break; 883 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 884 } 885 } 886 break; 887 } 888 case sstmssqlrevoke: { 889 lcisnewsql = true; 890 if (state != EFindSqlStateType.stnormal) { 891 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 892 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 893 lcisnewsql = false; 894 } 895 } 896 } 897 if (lcisnewsql) { 898 ret = new TRevokeStmt(vendor); 899 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 900 lctoken = lcsourcetokenlist.get(k); 901 if (lctoken.isnonsolidtoken()) continue; 902 if (lctoken.tokencode == TBaseType.rrw_go) break; 903 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 904 if (lctoken.tokencode == TBaseType.rrw_to) break; 905 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 906 } 907 } 908 break; 909 } 910 case sstmssqldeny: { 911 lcisnewsql = true; 912 if (state != EFindSqlStateType.stnormal) { 913 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 914 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 915 lcisnewsql = false; 916 } 917 } 918 } 919 if (lcisnewsql) { 920 ret = new TDenyStmt(vendor); 921 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 922 lctoken = lcsourcetokenlist.get(k); 923 if (lctoken.isnonsolidtoken()) continue; 924 if (lctoken.tokencode == TBaseType.rrw_go) break; 925 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 926 if (lctoken.tokencode == TBaseType.rrw_to) break; 927 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 928 } 929 } 930 break; 931 } 932 case sstmssqldeclare: { 933 ret = new TMssqlDeclare(vendor); 934 break; 935 } 936 case sstmssqlcontinue: { 937 ret = new TMssqlContinue(vendor); 938 break; 939 } 940 case sstbreak: { 941 ret = new TBreakStmt(vendor); 942 break; 943 } 944 case sstmssqlopen: { 945 ret = new TMssqlOpen(vendor); 946 break; 947 } 948 case sstmssqlclose: { 949 ret = new TMssqlClose(vendor); 950 break; 951 } 952 case sstmssqlbulkinsert: { 953 ret = new TMssqlBulkInsert(vendor); 954 break; 955 } 956 case sstmssqldeallocate: { 957 ret = new TMssqlDeallocate(vendor); 958 break; 959 } 960 case sstmssqlraiserror: { 961 ret = new TMssqlRaiserror(vendor); 962 break; 963 } 964 case sstmssqlgoto: { 965 ret = new TMssqlGoTo(vendor); 966 break; 967 } 968 case sstmssqldropview: { 969 ret = new TDropViewSqlStatement(vendor); 970 break; 971 } 972 case sstmssqldroptable: { 973 ret = new TDropTableSqlStatement(vendor); 974 break; 975 } 976 case sstmssqldropindex: { 977 ret = new TDropIndexSqlStatement(vendor); 978 break; 979 } 980 case sstmssqldroppartitionscheme: 981 ret = new TDropPartitionSchemeStmt(vendor); 982 break; 983 case sstmssqldropaggregate: 984 case sstmssqldropapplicationrole: 985 case sstmssqldropassembly: 986 case sstmssqldropasymmetrickey: 987 case sstmssqldropcertificate: 988 case sstmssqldropcontract: 989 case sstmssqldropcredential: 990 case sstmssqldropdefault: 991 case sstmssqldropendpoint: 992 case sstmssqldropeventnotification: 993 case sstmssqldropfulltextcatalog: 994 case sstmssqldropfulltextindex: 995 case sstmssqldroplogin: 996 case sstmssqldropmasterkey: 997 case sstmssqldropmessagetype: 998 case sstmssqldroppartitionfunction: 999 case sstmssqldropqueue: 1000 case sstmssqldropremoteservicebinding: 1001 case sstmssqldroprole: 1002 case sstmssqldroproute: 1003 case sstmssqldroprule: 1004 case sstmssqldropservice: 1005 case sstmssqldropsignature: 1006 case sstmssqldropstatistics: 1007 case sstmssqldropsymmetrickey: 1008 case sstmssqldroptrigger: 1009 case sstmssqldroptype: 1010 case sstmssqldropuser: 1011 case sstmssqldropxmlschemacollection: 1012 case sstmssqldropeventsession: { 1013 ret = new TMssqlDropDbObject(EDbVendor.dbvmssql); 1014 ret.sqlstatementtype = gnewsqlstatementtype; 1015 break; 1016 } 1017 case sstmssqldropsynonym: { 1018 ret = new TDropSynonymStmt(vendor); 1019 break; 1020 } 1021 case sstmssqldropprocedure: { 1022 ret = new TDropProcedureStmt(EDbVendor.dbvmssql); 1023 break; 1024 } 1025 case sstmssqldropdatabase: { 1026 ret = new TDropDatabaseStmt(EDbVendor.dbvmssql); 1027 break; 1028 } 1029 case sstmssqldropschema: { 1030 ret = new TDropSchemaSqlStatement(EDbVendor.dbvmssql); 1031 break; 1032 } 1033 case sstmssqltruncatetable: { 1034 ret = new TTruncateStatement(vendor); 1035 break; 1036 } 1037 case sstmssqlbegintran: { 1038 ret = new TBeginTran(vendor); 1039 break; 1040 } 1041 case sstmssqlsavetran: { 1042 if (vendor == EDbVendor.dbvodbc) { 1043 } else if (vendor == EDbVendor.dbvmssql) { 1044 ret = new TMssqlSaveTran(vendor); 1045 } 1046 break; 1047 } 1048 case sstmssqlcommit: { 1049 ret = new TMssqlCommit(vendor); 1050 break; 1051 } 1052 case sstmssqlrollback: { 1053 ret = new TMssqlRollback(vendor); 1054 break; 1055 } 1056 case sstmssqlreadtext: 1057 case sstmssqldbcc: 1058 case sstmssqlrestore: 1059 case sstmssqlbackup: { 1060 ret = new TMssqlDummyStmt(vendor); 1061 ret.sqlstatementtype = gnewsqlstatementtype; 1062 break; 1063 } 1064 case sstmssqlreceive: { 1065 lcisnewsql = true; 1066 if (state != EFindSqlStateType.stnormal) { 1067 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 1068 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect)) { 1069 lcisnewsql = false; 1070 } 1071 } 1072 } 1073 if (lcisnewsql) { 1074 ret = new TMssqlDummyStmt(vendor); 1075 ret.sqlstatementtype = gnewsqlstatementtype; 1076 } 1077 break; 1078 } 1079 case sstcreateindex: { 1080 ret = new TCreateIndexSqlStatement(vendor); 1081 break; 1082 } 1083 case sstmssqlwaitfor: { 1084 ret = new TMssqlWaitFor(vendor); 1085 break; 1086 } 1087 case sstmerge: { 1088 lcisnewsql = true; 1089 1090 if (state != EFindSqlStateType.stnormal) { 1091 if (lccurrentsqlstatement != null) { 1092 // merge union, merge join 1093 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect) { 1094 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1095 if (lcnextsolidtoken != null) { 1096 if ((lcnextsolidtoken.tokencode == TBaseType.rrw_union) || (lcnextsolidtoken.tokencode == TBaseType.rrw_join)) { 1097 lcisnewsql = false; 1098 } 1099 } 1100 } 1101 } 1102 if (lcisnewsql) { 1103 TSourceToken nextSt = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1104 if (nextSt != null) { 1105 if (nextSt.tokencode == TBaseType.rrw_join) { 1106 lcisnewsql = false; 1107 } 1108 } 1109 } 1110 } 1111 1112 if (lcisnewsql) { 1113 ret = new TMergeSqlStatement(vendor); 1114 ret.sqlstatementtype = gnewsqlstatementtype; 1115 } 1116 break; 1117 } 1118 case sstmssqlbegintry: 1119 case sstmssqlbegincatch: { 1120 ret = new TMssqlBlock(vendor); 1121 ret.sqlstatementtype = gnewsqlstatementtype; 1122 break; 1123 } 1124 case sstmssqlexec: { 1125 lcisnewsql = true; 1126 // prev tokentext can't be with 1127 if (state != EFindSqlStateType.stnormal) { 1128 if (TBaseType.assigned(lccurrentsqlstatement)) { 1129 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 1130 if (lccurrentsqlstatement.dummytag == 1) { 1131 lcisnewsql = false; 1132 lccurrentsqlstatement.dummytag = 0; // no select is permitted after it 1133 } 1134 1135 TSourceToken valuesToken = token.searchToken(TBaseType.rrw_values, -token.posinlist); 1136 if (valuesToken != null) { 1137 // If EXEC is after values in insert statement, then this EXEC is independent 1138 TSourceToken insertToken = lccurrentsqlstatement.sourcetokenlist.get(0); 1139 if (valuesToken.posinlist > insertToken.posinlist) { 1140 lcisnewsql = true; 1141 } 1142 } 1143 } 1144 1145 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 1146 if (TBaseType.assigned(lcprevsolidtoken)) { 1147 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 1148 lcisnewsql = false; 1149 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1150 lcisnewsql = false; 1151 } 1152 } 1153 1154 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateprocedure) 1155 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) 1156 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatefunction) 1157 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) 1158 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) 1159 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterfunction) 1160 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatequeue)) { 1161 if (TBaseType.assigned(lcprevsolidtoken)) { 1162 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) 1163 lcisnewsql = false; 1164 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1165 lcisnewsql = false; 1166 } 1167 } 1168 } 1169 } 1170 if (lcisnewsql) { 1171 ret = new TMssqlExecute(vendor); 1172 } 1173 break; 1174 } 1175 case sstmssqlexecuteas: { 1176 lcisnewsql = true; 1177 // prev tokentext can't be with 1178 if (state != EFindSqlStateType.stnormal) { 1179 if (TBaseType.assigned(lccurrentsqlstatement)) { 1180 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateprocedure) 1181 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) 1182 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatefunction) 1183 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) 1184 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) 1185 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterfunction)) { 1186 if (TBaseType.assigned(lcprevsolidtoken)) { 1187 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) 1188 lcisnewsql = false; 1189 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1190 lcisnewsql = false; 1191 } 1192 } 1193 } 1194 } 1195 if (lcisnewsql) { 1196 ret = new TMssqlExecuteAs(vendor); 1197 ret.sqlstatementtype = gnewsqlstatementtype; 1198 } 1199 break; 1200 } 1201 case sstmssqlset: { 1202 lcisnewsql = true; 1203 if (state != EFindSqlStateType.stnormal) { 1204 if (TBaseType.assigned(lccurrentsqlstatement)) { 1205 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif) { 1206 TSourceToken lcPPToken = lcsourcetokenlist.searchToken(TBaseType.rrw_update, "", token, -10); 1207 if (TBaseType.assigned(lcPPToken)) { 1208 lcisnewsql = false; 1209 } 1210 } 1211 1212 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstalterdatabase) { 1213 TSourceToken lcPPToken = lcsourcetokenlist.searchToken(TBaseType.rrw_alter, "", token, -10); 1214 if (TBaseType.assigned(lcPPToken)) { 1215 lcisnewsql = false; 1216 } 1217 } 1218 1219 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 1220 if (lcprevsolidtoken != null) { 1221 if (lcprevsolidtoken.tokencode == TBaseType.rrw_update) { 1222 lcisnewsql = false; 1223 } 1224 } 1225 } 1226 1227 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstupdate) { 1228 if (lccurrentsqlstatement.dummytag == 1) { 1229 // update statement still find set clause yet, so this is set clause in update statement 1230 lccurrentsqlstatement.dummytag = 0; 1231 lcisnewsql = false; 1232 } 1233 } 1234 1235 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateeventsession) { 1236 lcisnewsql = false; 1237 } 1238 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) { 1239 lcisnewsql = false; 1240 } 1241 } 1242 1243 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1244 if (TBaseType.assigned(lcnextsolidtoken)) { 1245 // set null, set default 1246 if ((TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "null") == 0) 1247 || (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "default") == 0)) { 1248 lcisnewsql = false; 1249 } 1250 } 1251 } 1252 1253 if (lcisnewsql) { 1254 ret = new TMssqlSet(vendor); 1255 } 1256 break; 1257 } 1258 case sstmssqlsetrowcount: { 1259 ret = new TMssqlSetRowCount(vendor); 1260 break; 1261 } 1262 case sstmssqlupdatetext: { 1263 ret = new TMssqlUpdateText(vendor); 1264 break; 1265 } 1266 case sstmssqlendconversation: { 1267 ret = new TMssqlEndConversation(vendor); 1268 break; 1269 } 1270 case sstmssqlbegindialog: { 1271 ret = new TMssqlBeginDialog(vendor); 1272 break; 1273 } 1274 case sstmssqlsendonconversation: { 1275 ret = new TMssqlSendOnConversation(vendor); 1276 break; 1277 } 1278 case sstdropsequence: 1279 ret = new TDropSequenceStmt(vendor); 1280 break; 1281 case sstmssqldisabletrigger: 1282 case sstmssqlenabletrigger: { 1283 lcisnewsql = true; 1284 if (TBaseType.assigned(lccurrentsqlstatement)) { 1285 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) 1286 lcisnewsql = false; 1287 } 1288 1289 if (lcisnewsql) { 1290 ret = new TUnknownSqlStatement(vendor); 1291 ret.sqlstatementtype = gnewsqlstatementtype; 1292 } 1293 break; 1294 } 1295 case sstmssqlthrow: 1296 ret = new TMssqlThrow(vendor); 1297 break; 1298 case sstmssqlalterdatabase: 1299 ret = new TAlterDatabaseStmt(vendor); 1300 break; 1301 case sstmssqlreconfigure: 1302 ret = new TReconfigure(vendor); 1303 break; 1304 case sstcreatedatabase: { 1305 ret = new TCreateDatabaseSqlStatement(vendor); 1306 break; 1307 } 1308 case sstmssqlcreateschema: { 1309 ret = new TCreateSchemaSqlStatement(vendor); 1310 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 1311 lctoken = lcsourcetokenlist.get(k); 1312 if (lctoken.isnonsolidtoken()) continue; 1313 if (lctoken.tokencode == TBaseType.rrw_go) break; 1314 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 1315 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 1316 } 1317 break; 1318 } 1319 case sstmssqlcreatesynonym: { 1320 ret = new TCreateSynonymStmt(vendor); 1321 break; 1322 } 1323 case sstmssqlcreatetype: 1324 ret = new TMssqlCreateType(vendor); 1325 break; 1326 case sstmssqlcreatexmlschemacollection: 1327 ret = new TMssqlCreateXmlSchemaCollectionStmt(vendor); 1328 break; 1329 case sstmssqlalterindex: 1330 ret = new TAlterIndexStmt(vendor); 1331 break; 1332 case sstmssqlcreateevexternalDataSource: 1333 ret = new TCreateExternalDataSourceStmt(vendor); 1334 break; 1335 case sstmssqlcreateeventsession: 1336 ret = new TCreateEventSession(vendor); 1337 break; 1338 case sstmssqldropfunction: 1339 ret = new TDropFunctionStmt(vendor); 1340 break; 1341 case sstmssqlcreateevexternalLanguage: 1342 ret = new TCreateExternalLanguage(vendor); 1343 break; 1344 case sstmssqlalterview: { 1345 lcisnewsql = true; 1346 if (TBaseType.assigned(lccurrentsqlstatement)) { 1347 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 1348 lcisnewsql = false; 1349 } 1350 1351 if (lcisnewsql) { 1352 ret = new TAlterViewStatement(vendor); 1353 } 1354 break; 1355 } 1356 case sstCreateFileFormat: { 1357 ret = new TCreateFileFormatStmt(vendor); 1358 break; 1359 } 1360 case sstmssqlcreatemasterkey: 1361 ret = new TCreateMasterKeyStmt(vendor); 1362 break; 1363 case sstcreatecredential: 1364 ret = new TCreateCredentialStmt(vendor); 1365 break; 1366 case sstCopyInto: { 1367 ret = new TMssqlCopyIntoStmt(vendor); 1368 break; 1369 } 1370 case sstcreatematerializedview: { 1371 ret = new TCreateMaterializedSqlStatement(vendor); 1372 break; 1373 } 1374 case sstmssqlCreateSecurityPolicy: 1375 ret = new TMssqlCreateSecurityPolicy(vendor); 1376 break; 1377 case sstmssqlAlterSecurityPolicy: 1378 ret = new TMssqlAlterSecurityPolicy(vendor); 1379 break; 1380 case sstmssqlDropSecurityPolicy: 1381 ret = new TMssqlDropSecurityPolicy(vendor); 1382 break; 1383 case sstmssqlalterpartitionfunction: 1384 ret = new TAlterPartitionFunctionStmt(vendor); 1385 break; 1386 case sstmssqlcreatepartitionfunction: 1387 ret = new TCreatePartitionFunctionStmt(vendor); 1388 break; 1389 case sstmssqlalterpartitionscheme: 1390 ret = new TAlterPartitionSchemeSqlStatement(vendor); 1391 break; 1392 case sstmssqlcreatepartitionscheme: 1393 ret = new TCreatePartitionSchemeSqlStatement(vendor); 1394 break; 1395 default: { 1396 ret = new TUnknownSqlStatement(vendor); 1397 ret.sqlstatementtype = gnewsqlstatementtype; 1398 break; 1399 } 1400 } 1401 return ret; 1402 } 1403 1404 1405}