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