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 // CTE starting without semicolon after previous DML statement 478 if ((state != EFindSqlStateType.stnormal) && (token.tokencode == TBaseType.rrw_with) 479 && lccurrentsqlstatement != null 480 && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect 481 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstupdate 482 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdelete)) { 483 TSourceToken nextSolid = token.nextSolidToken(); 484 // WITH followed by ( is a table hint, not a CTE; require WITH <name> AS pattern 485 if (nextSolid != null && nextSolid.tokentype != ETokenType.ttleftparenthesis) { 486 TSourceToken afterName = nextSolid.nextSolidToken(); 487 if (afterName != null && (afterName.tokencode == TBaseType.rrw_as 488 || afterName.tokentype == ETokenType.ttleftparenthesis)) { 489 ret = findcte(token); 490 if (ret != null) return ret; 491 } 492 } 493 } 494 495 if ((lccurrentsqlstatement != null) && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 496 && (token.tokencode == TBaseType.rrw_with)) { 497 TSourceToken lcPrevToken = token.prevSolidToken(); 498 if ((lcPrevToken != null) && (lcPrevToken.tokencode == TBaseType.rrw_as)) { 499 // mantisbt/view.php?id=3900, create table with as select, ignore tokens from with to select 500 ret = findcte(token); 501 if ((ret != null)) { 502 ret = null; 503 } 504 } 505 } 506 507 // ODBC 508 if ((state == EFindSqlStateType.stnormal) && ((token.tokencode == '{') || (token.tokencode == TBaseType.odbc_esc_prefix)) && (token.getLinkToken() != null)) { 509 ret = new TCallStatement(vendor); 510 return ret; 511 } 512 513 gnewsqlstatementtype = super.getStatementTypeForToken(token); 514 515 // Don't split inside stub-like statements - they consume everything until semicolon 516 if (state != EFindSqlStateType.stnormal && lccurrentsqlstatement != null 517 && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlstmtstub 518 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateserveraudit 519 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatedatabaseauditspecification) 520 && gnewsqlstatementtype != ESqlStatementType.sstinvalid) { 521 gnewsqlstatementtype = ESqlStatementType.sstinvalid; 522 return ret; 523 } 524 525 TSourceToken lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 526 switch (gnewsqlstatementtype) { 527 case sstinvalid: { 528 if (token.tokencode == TBaseType.mslabel) { 529 ret = new TMssqlLabel(vendor); 530 } else 531 ret = null; 532 break; 533 } 534 case sstselect: { 535 lcisnewsql = true; 536 537 if (state != EFindSqlStateType.stnormal) { 538 if ((lcprevsolidtoken != null)) { 539 if (lcprevsolidtoken.tokentype == ETokenType.ttleftparenthesis) 540 lcisnewsql = false; // subquery 541 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_union) 542 lcisnewsql = false; 543 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_intersect) 544 lcisnewsql = false; 545 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_minus) 546 lcisnewsql = false; 547 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_except) 548 lcisnewsql = false; 549 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_return) 550 lcisnewsql = false; 551 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_as) { 552 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 553 lcisnewsql = false; 554 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 555 lcisnewsql = false; 556 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatematerializedview) 557 lcisnewsql = false; 558 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstalterview) 559 lcisnewsql = false; 560 } else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) { 561 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlset) 562 lcisnewsql = false; 563 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqldeclare) 564 lcisnewsql = false; 565 } 566 567 if (lcisnewsql && (lcprevsolidtoken.tokencode == TBaseType.rrw_all)) { 568 lcpprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcprevsolidtoken.posinlist); 569 if ((lcpprevsolidtoken != null)) { 570 if (lcpprevsolidtoken.tokencode == TBaseType.rrw_union) 571 lcisnewsql = false; 572 } 573 } 574 } 575 576 if ((lccurrentsqlstatement != null)) { 577 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 578 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 579 if ((lcprevsolidtoken != null)) { 580 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 581 lcisnewsql = false; 582 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 583 lcisnewsql = false; 584 } 585 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview 586 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatematerializedview) { 587 // In CREATE VIEW, SELECT is part of the view body when preceded by ')' 588 // (e.g., CTE anchor query: WITH cte AS (...) SELECT). 589 // Other continuation cases (AS, UNION, UNION ALL, INTERSECT, EXCEPT, 590 // subquery) are already handled by the earlier checks above. 591 // If none of those match, this SELECT starts a new statement. 592 if (lcprevsolidtoken != null 593 && lcprevsolidtoken.tokentype == ETokenType.ttrightparenthesis) { 594 lcisnewsql = false; 595 } 596 } 597 } 598 } 599 600 if (lcisnewsql) 601 ret = new TSelectSqlStatement(vendor); 602 break; 603 } 604 case sstinsert: { 605 lcisnewsql = true; 606 if (state != EFindSqlStateType.stnormal) { 607 if ((lccurrentsqlstatement != null)) { 608 // merge 609 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 610 if (lcprevsolidtoken != null) { 611 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 612 lcisnewsql = false; 613 } 614 } 615 } 616 617 // bulk insert 618 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlbulkinsert) { 619 if ((lcprevsolidtoken != null)) { 620 if (lcprevsolidtoken.tokencode == TBaseType.rrw_bulk) 621 lcisnewsql = false; 622 } 623 } 624 625 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 626 if ((lcprevsolidtoken != null)) { 627 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 628 lcisnewsql = false; 629 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 630 lcisnewsql = false; 631 } 632 } 633 634 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger 635 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) { 636 if ((lcprevsolidtoken != null)) { 637 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 638 lcisnewsql = false; 639 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 640 lcisnewsql = false; 641 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 642 lcisnewsql = false; 643 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 644 lcisnewsql = false; 645 } 646 } 647 648 // CREATE SECURITY POLICY ... AFTER INSERT 649 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlCreateSecurityPolicy) { 650 if ((lcprevsolidtoken != null)) { 651 if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 652 lcisnewsql = false; 653 } 654 } 655 } 656 } 657 658 if (lcisnewsql) { 659 ret = new TInsertSqlStatement(vendor); 660 ret.dummytag = 1; // select stmt in insert is permitted 661 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 662 if (lcsourcetokenlist.get(k).isnonsolidtoken()) continue; 663 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_values) break; 664 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_go) break; 665 if (lcsourcetokenlist.get(k).tokentype == ETokenType.ttsemicolon) break; 666 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_select) { 667 ret.dummytag = 0; 668 break; 669 } 670 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_execute) break; 671 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_exec) break; 672 } 673 if (k > lcsourcetokenlist.size() - 1) 674 k = lcsourcetokenlist.size() - 1; 675 676 for (int i = lcpos + 1; i <= k; i++) { 677 lcsourcetokenlist.get(i).tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 678 } 679 } 680 break; 681 } 682 case sstupdate: { 683 lcisnewsql = true; 684 if (state != EFindSqlStateType.stnormal) { 685 if ((lcprevsolidtoken != null)) { 686 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 687 lcisnewsql = false; 688 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 689 lcisnewsql = false; 690 } 691 692 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 693 if (TBaseType.assigned(lcnextsolidtoken)) { 694 if (lcnextsolidtoken.tokentype == ETokenType.ttleftparenthesis) { 695 k = lcsourcetokenlist.solidtokenafterpos(lcnextsolidtoken.posinlist, TBaseType.rrw_select, 1, "("); 696 if (k == 0) lcisnewsql = false; 697 } 698 } 699 700 if (TBaseType.assigned(lccurrentsqlstatement)) { 701 // merge 702 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 703 if (lcprevsolidtoken != null) { 704 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 705 lcisnewsql = false; 706 } 707 } 708 } 709 710 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 711 if (TBaseType.assigned(lcprevsolidtoken)) { 712 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 713 lcisnewsql = false; 714 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 715 lcisnewsql = false; 716 } 717 } 718 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger 719 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) { 720 if (TBaseType.assigned(lcprevsolidtoken)) { 721 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 722 lcisnewsql = false; 723 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 724 lcisnewsql = false; 725 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 726 lcisnewsql = false; 727 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 728 lcisnewsql = false; 729 } 730 } 731 732 // CREATE SECURITY POLICY ... AFTER UPDATE / BEFORE UPDATE 733 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlCreateSecurityPolicy) { 734 if (TBaseType.assigned(lcprevsolidtoken)) { 735 if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 736 lcisnewsql = false; 737 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "before") == 0) 738 lcisnewsql = false; 739 } 740 } 741 } 742 } 743 744 if (lcisnewsql) { 745 ret = new TUpdateSqlStatement(vendor); 746 ret.dummytag = 1; // means set clause in update is not found yet 747 } 748 break; 749 } 750 case sstdelete: { 751 lcisnewsql = true; 752 753 if (state != EFindSqlStateType.stnormal) { 754 lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 755 if (TBaseType.assigned(lcprevsolidtoken)) { 756 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 757 lcisnewsql = false; 758 } 759 760 if (TBaseType.assigned(lccurrentsqlstatement)) { 761 // merge 762 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 763 if (lcprevsolidtoken != null) { 764 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 765 lcisnewsql = false; 766 } 767 } 768 } 769 770 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 771 if (TBaseType.assigned(lcprevsolidtoken)) { 772 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 773 lcisnewsql = false; 774 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 775 lcisnewsql = false; 776 } 777 } 778 779 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger 780 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) { 781 if (TBaseType.assigned(lcprevsolidtoken)) { 782 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 783 lcisnewsql = false; 784 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 785 lcisnewsql = false; 786 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 787 lcisnewsql = false; 788 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 789 lcisnewsql = false; 790 } 791 } 792 793 // CREATE SECURITY POLICY ... BEFORE DELETE 794 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlCreateSecurityPolicy) { 795 if (TBaseType.assigned(lcprevsolidtoken)) { 796 if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "before") == 0) 797 lcisnewsql = false; 798 } 799 } 800 } 801 } 802 803 if (lcisnewsql) 804 ret = new TDeleteSqlStatement(vendor); 805 break; 806 } 807 case sstcreatetable: { 808 lcisnewsql = true; 809 if (state != EFindSqlStateType.stnormal) { 810 if (TBaseType.assigned(lccurrentsqlstatement)) { 811 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 812 lcisnewsql = false; 813 } 814 } 815 } 816 817 if (lcisnewsql) { 818 ret = new TCreateTableSqlStatement(vendor); 819 } 820 break; 821 } 822 case sstcreateview: { 823 lcisnewsql = true; 824 if (state != EFindSqlStateType.stnormal) { 825 if (TBaseType.assigned(lccurrentsqlstatement)) { 826 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 827 lcisnewsql = false; 828 } 829 } 830 } 831 if (lcisnewsql) { 832 ret = new TCreateViewSqlStatement(vendor); 833 } 834 break; 835 } 836 case sstcreatesequence: { 837 ret = new TCreateSequenceStmt(vendor); 838 break; 839 } 840 case sstaltertable: { 841 ret = new TAlterTableStatement(vendor); 842 break; 843 } 844 case sstmssqlfetch: { 845 ret = new TMssqlFetch(vendor); 846 break; 847 } 848 case sstmssqlif: { 849 lcisnewsql = true; 850 if (state != EFindSqlStateType.stnormal) { 851 if (TBaseType.assigned(lccurrentsqlstatement)) { 852 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropprocedure) 853 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropdatabase) 854 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropfunction) 855 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlDropSecurityPolicy)) { 856 lcisnewsql = false; 857 } else if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdroptable) 858 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropindex) 859 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 860 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropsynonym) 861 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropview) 862 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropsequence) 863 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqldroptrigger)) { 864 // DROP TABLE IF EXISTS T1; 865 TSourceToken st = lcsourcetokenlist.solidtokenbefore(lcpos); 866 if ((st.tokencode == TBaseType.rrw_table) || (st.tokencode == TBaseType.rrw_index) 867 || (st.tokencode == TBaseType.rrw_sqlserver_synonym) || (st.tokencode == TBaseType.rrw_view) 868 || (st.tokencode == TBaseType.rrw_sqlserver_sequence) || (st.toString().equalsIgnoreCase("trigger"))) { 869 lcisnewsql = false; 870 } 871 } else if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable)) { 872 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 873 if (lcnextsolidtoken != null) { 874 if (lcnextsolidtoken.tokencode == TBaseType.rrw_sqlserver_exists) { 875 lcisnewsql = false; 876 } 877 } 878 } 879 } 880 } 881 882 if (lcisnewsql) { 883 ret = new TMssqlIfElse(vendor); 884 ret.dummytag = 1; // reduce to 0 while stmt find in 'if (condition stmt' || 'else stmt' 885 } 886 break; 887 } 888 case sstmssqlwhile: { 889 ret = new TMssqlIfElse(vendor); 890 ret.sqlstatementtype = ESqlStatementType.sstmssqlwhile; 891 ret.dummytag = 1; // reduce to 0 while stmt find in 'if (condition stmt' || 'else stmt' 892 break; 893 } 894 case sstmssqlcreateprocedure: 895 case sstmssqlalterprocedure: { 896 ret = new TMssqlCreateProcedure(vendor); 897 if (gnewsqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) { 898 ret.sqlstatementtype = ESqlStatementType.sstmssqlalterprocedure; 899 } 900 break; 901 } 902 case sstmssqlcreatefunction: 903 case sstmssqlalterfunction: { 904 ret = new TMssqlCreateFunction(vendor); 905 if (gnewsqlstatementtype == ESqlStatementType.sstmssqlalterfunction) { 906 ret.sqlstatementtype = ESqlStatementType.sstmssqlalterfunction; 907 } 908 break; 909 } 910 case sstcreatetrigger: 911 case sstmssqlaltertrigger: { 912 ret = new TCreateTriggerStmt(vendor); 913 if (gnewsqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) { 914 ret.sqlstatementtype = ESqlStatementType.sstmssqlaltertrigger; 915 } 916 break; 917 } 918 case sstmssqlreturn: { 919 ret = new TMssqlReturn(vendor); 920 break; 921 } 922 case sstmssqlprint: { 923 if (vendor == EDbVendor.dbvodbc) { 924 } else if (vendor == EDbVendor.dbvmssql) { 925 ret = new TMssqlPrint(vendor); 926 } 927 break; 928 } 929 case sstmssqluse: { 930 lcisnewsql = true; 931 if (state != EFindSqlStateType.stnormal) { 932 if (TBaseType.assigned(lcprevsolidtoken)) { 933 // USE HINT inside OPTION clause: prev token is comma or left paren 934 if (lcprevsolidtoken.tokentype == ETokenType.ttcomma 935 || lcprevsolidtoken.tokentype == ETokenType.ttleftparenthesis) { 936 lcisnewsql = false; 937 } 938 } 939 } 940 if (lcisnewsql) { 941 ret = new TUseDatabase(vendor); 942 } 943 break; 944 } 945 case sstmssqlgo: { 946 ret = new TMssqlGo(vendor); 947 break; 948 } 949 case sstmssqlrevert: { 950 lcisnewsql = true; 951 // prev tokentext can't be with 952 if (state != EFindSqlStateType.stnormal) { 953 if (TBaseType.assigned(lcprevsolidtoken)) { 954 if (lcprevsolidtoken.toString().equalsIgnoreCase("no")) { 955 ret = null; 956 lcisnewsql = false; 957 } 958 } 959 } 960 if (lcisnewsql) { 961 ret = new TMssqlRevert(vendor); 962 } 963 break; 964 } 965 case sstmssqlgrant: { 966 lcisnewsql = true; 967 // prev tokentext can't be with 968 if (state != EFindSqlStateType.stnormal) { 969 if (TBaseType.assigned(lcprevsolidtoken)) { 970 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) { 971 ret = null; 972 lcisnewsql = false; 973 } 974 } 975 976 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 977 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 978 lcisnewsql = false; 979 } 980 } 981 } 982 if (lcisnewsql) { 983 ret = new TGrantStmt(vendor); 984 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 985 lctoken = lcsourcetokenlist.get(k); 986 if (lctoken.isnonsolidtoken()) continue; 987 if (lctoken.tokencode == TBaseType.rrw_go) break; 988 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 989 if (lctoken.tokencode == TBaseType.rrw_to) break; 990 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 991 } 992 } 993 break; 994 } 995 case sstmssqlrevoke: { 996 lcisnewsql = true; 997 if (state != EFindSqlStateType.stnormal) { 998 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 999 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 1000 lcisnewsql = false; 1001 } 1002 } 1003 } 1004 if (lcisnewsql) { 1005 ret = new TRevokeStmt(vendor); 1006 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 1007 lctoken = lcsourcetokenlist.get(k); 1008 if (lctoken.isnonsolidtoken()) continue; 1009 if (lctoken.tokencode == TBaseType.rrw_go) break; 1010 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 1011 if (lctoken.tokencode == TBaseType.rrw_to) break; 1012 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 1013 } 1014 } 1015 break; 1016 } 1017 case sstmssqldeny: { 1018 lcisnewsql = true; 1019 if (state != EFindSqlStateType.stnormal) { 1020 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 1021 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 1022 lcisnewsql = false; 1023 } 1024 } 1025 } 1026 if (lcisnewsql) { 1027 ret = new TDenyStmt(vendor); 1028 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 1029 lctoken = lcsourcetokenlist.get(k); 1030 if (lctoken.isnonsolidtoken()) continue; 1031 if (lctoken.tokencode == TBaseType.rrw_go) break; 1032 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 1033 if (lctoken.tokencode == TBaseType.rrw_to) break; 1034 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 1035 } 1036 } 1037 break; 1038 } 1039 case sstmssqldeclare: { 1040 ret = new TMssqlDeclare(vendor); 1041 break; 1042 } 1043 case sstmssqlcontinue: { 1044 ret = new TMssqlContinue(vendor); 1045 break; 1046 } 1047 case sstbreak: { 1048 ret = new TBreakStmt(vendor); 1049 break; 1050 } 1051 case sstmssqlopen: { 1052 ret = new TMssqlOpen(vendor); 1053 break; 1054 } 1055 case sstmssqlclose: { 1056 ret = new TMssqlClose(vendor); 1057 break; 1058 } 1059 case sstmssqlbulkinsert: { 1060 ret = new TMssqlBulkInsert(vendor); 1061 break; 1062 } 1063 case sstmssqldeallocate: { 1064 ret = new TMssqlDeallocate(vendor); 1065 break; 1066 } 1067 case sstmssqlraiserror: { 1068 ret = new TMssqlRaiserror(vendor); 1069 break; 1070 } 1071 case sstmssqlgoto: { 1072 ret = new TMssqlGoTo(vendor); 1073 break; 1074 } 1075 case sstmssqldropview: { 1076 ret = new TDropViewSqlStatement(vendor); 1077 break; 1078 } 1079 case sstmssqldroptable: { 1080 ret = new TDropTableSqlStatement(vendor); 1081 break; 1082 } 1083 case sstmssqldropindex: { 1084 ret = new TDropIndexSqlStatement(vendor); 1085 break; 1086 } 1087 case sstmssqldroppartitionscheme: 1088 ret = new TDropPartitionSchemeStmt(vendor); 1089 break; 1090 case sstmssqldroppartitionfunction: 1091 ret = new gudusoft.gsqlparser.stmt.mssql.TDropPartitionFunctionStmt(vendor); 1092 break; 1093 case sstmssqldropaggregate: 1094 case sstmssqldropapplicationrole: 1095 case sstmssqldropassembly: 1096 case sstmssqldropasymmetrickey: 1097 case sstmssqldropcertificate: 1098 case sstmssqldropcontract: 1099 case sstmssqldropcredential: 1100 case sstmssqldropdefault: 1101 case sstmssqldropendpoint: 1102 case sstmssqldropeventnotification: 1103 case sstmssqldropfulltextcatalog: 1104 case sstmssqldropfulltextindex: 1105 case sstmssqldroplogin: 1106 case sstmssqldropmasterkey: 1107 case sstmssqldropmessagetype: 1108 case sstmssqldropqueue: 1109 case sstmssqldropremoteservicebinding: 1110 case sstmssqldroprole: 1111 case sstmssqldroproute: 1112 case sstmssqldroprule: 1113 case sstmssqldropservice: 1114 case sstmssqldropsignature: 1115 case sstmssqldropstatistics: 1116 case sstmssqldropsymmetrickey: 1117 case sstmssqldroptrigger: 1118 case sstmssqldroptype: 1119 case sstmssqldropuser: 1120 case sstmssqldropxmlschemacollection: 1121 case sstmssqldropeventsession: { 1122 ret = new TMssqlDropDbObject(EDbVendor.dbvmssql); 1123 ret.sqlstatementtype = gnewsqlstatementtype; 1124 break; 1125 } 1126 case sstmssqldropsynonym: { 1127 ret = new TDropSynonymStmt(vendor); 1128 break; 1129 } 1130 case sstmssqldropprocedure: { 1131 ret = new TDropProcedureStmt(EDbVendor.dbvmssql); 1132 break; 1133 } 1134 case sstmssqldropdatabase: { 1135 ret = new TDropDatabaseStmt(EDbVendor.dbvmssql); 1136 break; 1137 } 1138 case sstmssqldropschema: { 1139 ret = new TDropSchemaSqlStatement(EDbVendor.dbvmssql); 1140 break; 1141 } 1142 case sstmssqltruncatetable: { 1143 ret = new TTruncateStatement(vendor); 1144 break; 1145 } 1146 case sstmssqlbegintran: { 1147 ret = new TBeginTran(vendor); 1148 break; 1149 } 1150 case sstmssqlsavetran: { 1151 if (vendor == EDbVendor.dbvodbc) { 1152 } else if (vendor == EDbVendor.dbvmssql) { 1153 ret = new TMssqlSaveTran(vendor); 1154 } 1155 break; 1156 } 1157 case sstmssqlcommit: { 1158 ret = new TMssqlCommit(vendor); 1159 break; 1160 } 1161 case sstmssqlrollback: { 1162 ret = new TMssqlRollback(vendor); 1163 break; 1164 } 1165 case sstmssqlreadtext: 1166 case sstmssqldbcc: 1167 case sstmssqlrestore: 1168 case sstmssqlbackup: { 1169 ret = new TMssqlDummyStmt(vendor); 1170 ret.sqlstatementtype = gnewsqlstatementtype; 1171 break; 1172 } 1173 case sstmssqlreceive: { 1174 lcisnewsql = true; 1175 if (state != EFindSqlStateType.stnormal) { 1176 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 1177 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect)) { 1178 lcisnewsql = false; 1179 } 1180 } 1181 } 1182 if (lcisnewsql) { 1183 ret = new TMssqlDummyStmt(vendor); 1184 ret.sqlstatementtype = gnewsqlstatementtype; 1185 } 1186 break; 1187 } 1188 case sstcreateindex: { 1189 ret = new TCreateIndexSqlStatement(vendor); 1190 break; 1191 } 1192 case sstmssqlwaitfor: { 1193 ret = new TMssqlWaitFor(vendor); 1194 break; 1195 } 1196 case sstmerge: { 1197 lcisnewsql = true; 1198 1199 if (state != EFindSqlStateType.stnormal) { 1200 if (lccurrentsqlstatement != null) { 1201 // merge union, merge join 1202 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect) { 1203 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1204 if (lcnextsolidtoken != null) { 1205 if ((lcnextsolidtoken.tokencode == TBaseType.rrw_union) || (lcnextsolidtoken.tokencode == TBaseType.rrw_join)) { 1206 lcisnewsql = false; 1207 } 1208 } 1209 } 1210 // ALTER TABLE ... MERGE RANGE (value) 1211 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) { 1212 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1213 if (lcnextsolidtoken != null) { 1214 if (lcnextsolidtoken.toString().equalsIgnoreCase("RANGE")) { 1215 lcisnewsql = false; 1216 } 1217 } 1218 } 1219 } 1220 if (lcisnewsql) { 1221 TSourceToken nextSt = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1222 if (nextSt != null) { 1223 if (nextSt.tokencode == TBaseType.rrw_join) { 1224 lcisnewsql = false; 1225 } 1226 } 1227 } 1228 } 1229 1230 if (lcisnewsql) { 1231 ret = new TMergeSqlStatement(vendor); 1232 ret.sqlstatementtype = gnewsqlstatementtype; 1233 } 1234 break; 1235 } 1236 case sstmssqlbegintry: 1237 case sstmssqlbegincatch: { 1238 ret = new TMssqlBlock(vendor); 1239 ret.sqlstatementtype = gnewsqlstatementtype; 1240 break; 1241 } 1242 case sstmssqlexec: { 1243 lcisnewsql = true; 1244 // prev tokentext can't be with 1245 if (state != EFindSqlStateType.stnormal) { 1246 if (TBaseType.assigned(lccurrentsqlstatement)) { 1247 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 1248 if (lccurrentsqlstatement.dummytag == 1) { 1249 lcisnewsql = false; 1250 lccurrentsqlstatement.dummytag = 0; // no select is permitted after it 1251 } 1252 1253 TSourceToken valuesToken = token.searchToken(TBaseType.rrw_values, -token.posinlist); 1254 if (valuesToken != null) { 1255 // If EXEC is after values in insert statement, then this EXEC is independent 1256 TSourceToken insertToken = lccurrentsqlstatement.sourcetokenlist.get(0); 1257 if (valuesToken.posinlist > insertToken.posinlist) { 1258 lcisnewsql = true; 1259 } 1260 } 1261 } 1262 1263 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 1264 if (TBaseType.assigned(lcprevsolidtoken)) { 1265 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 1266 lcisnewsql = false; 1267 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1268 lcisnewsql = false; 1269 } 1270 } 1271 1272 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateprocedure) 1273 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) 1274 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatefunction) 1275 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) 1276 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) 1277 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterfunction) 1278 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatequeue)) { 1279 if (TBaseType.assigned(lcprevsolidtoken)) { 1280 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) 1281 lcisnewsql = false; 1282 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1283 lcisnewsql = false; 1284 } 1285 } 1286 } 1287 } 1288 if (lcisnewsql) { 1289 ret = new TMssqlExecute(vendor); 1290 } 1291 break; 1292 } 1293 case sstmssqlexecuteas: { 1294 lcisnewsql = true; 1295 // prev tokentext can't be with 1296 if (state != EFindSqlStateType.stnormal) { 1297 if (TBaseType.assigned(lccurrentsqlstatement)) { 1298 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateprocedure) 1299 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) 1300 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatefunction) 1301 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) 1302 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) 1303 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterfunction)) { 1304 if (TBaseType.assigned(lcprevsolidtoken)) { 1305 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) 1306 lcisnewsql = false; 1307 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1308 lcisnewsql = false; 1309 } 1310 } 1311 } 1312 } 1313 if (lcisnewsql) { 1314 ret = new TMssqlExecuteAs(vendor); 1315 ret.sqlstatementtype = gnewsqlstatementtype; 1316 } 1317 break; 1318 } 1319 case sstmssqlset: { 1320 lcisnewsql = true; 1321 if (state != EFindSqlStateType.stnormal) { 1322 if (TBaseType.assigned(lccurrentsqlstatement)) { 1323 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif) { 1324 TSourceToken lcPPToken = lcsourcetokenlist.searchToken(TBaseType.rrw_update, "", token, -10); 1325 if (TBaseType.assigned(lcPPToken)) { 1326 lcisnewsql = false; 1327 } 1328 } 1329 1330 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstalterdatabase) { 1331 TSourceToken lcPPToken = lcsourcetokenlist.searchToken(TBaseType.rrw_alter, "", token, -10); 1332 if (TBaseType.assigned(lcPPToken)) { 1333 lcisnewsql = false; 1334 } 1335 } 1336 1337 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 1338 if (lcprevsolidtoken != null) { 1339 if (lcprevsolidtoken.tokencode == TBaseType.rrw_update) { 1340 lcisnewsql = false; 1341 } 1342 } 1343 } 1344 1345 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstupdate) { 1346 if (lccurrentsqlstatement.dummytag == 1) { 1347 // update statement still find set clause yet, so this is set clause in update statement 1348 lccurrentsqlstatement.dummytag = 0; 1349 lcisnewsql = false; 1350 } 1351 } 1352 1353 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateeventsession) { 1354 lcisnewsql = false; 1355 } 1356 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) { 1357 // Only treat SET as part of ALTER TABLE for SET NULL/SET DEFAULT/SET (...) 1358 // Other SET variants (e.g. SET ANSI_PADDING) should start a new statement 1359 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1360 if (TBaseType.assigned(lcnextsolidtoken)) { 1361 if ((TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "null") == 0) 1362 || (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "default") == 0) 1363 || (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "(") == 0)) { 1364 lcisnewsql = false; 1365 } 1366 } 1367 } 1368 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterindex) { 1369 // ALTER INDEX ... SET ( option = value, ... ) — SET is part of the ALTER INDEX 1370 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1371 if (TBaseType.assigned(lcnextsolidtoken)) { 1372 if (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "(") == 0) { 1373 lcisnewsql = false; 1374 } 1375 } 1376 } 1377 } 1378 // ALTER INDEX ... SET (...) : the previous statement may have already been 1379 // closed; look back for "ALTER INDEX" pattern 1380 if (lcisnewsql) { 1381 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1382 if (TBaseType.assigned(lcnextsolidtoken) 1383 && TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "(") == 0) { 1384 TSourceToken lcAlterToken = lcsourcetokenlist.searchToken(TBaseType.rrw_alter, "", token, -20); 1385 if (TBaseType.assigned(lcAlterToken)) { 1386 TSourceToken lcAfterAlter = lcsourcetokenlist.nextsolidtoken(lcAlterToken.posinlist, 1, false); 1387 if (TBaseType.assigned(lcAfterAlter) 1388 && TBaseType.mycomparetext(lcAfterAlter.getAstext(), "index") == 0) { 1389 lcisnewsql = false; 1390 } 1391 } 1392 } 1393 } 1394 1395 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1396 if (TBaseType.assigned(lcnextsolidtoken)) { 1397 // set null, set default 1398 if ((TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "null") == 0) 1399 || (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "default") == 0)) { 1400 lcisnewsql = false; 1401 } 1402 } 1403 } 1404 1405 if (lcisnewsql) { 1406 ret = new TMssqlSet(vendor); 1407 } 1408 break; 1409 } 1410 case sstmssqlsetrowcount: { 1411 ret = new TMssqlSetRowCount(vendor); 1412 break; 1413 } 1414 case sstmssqlupdatetext: { 1415 ret = new TMssqlUpdateText(vendor); 1416 break; 1417 } 1418 case sstmssqlendconversation: { 1419 ret = new TMssqlEndConversation(vendor); 1420 break; 1421 } 1422 case sstmssqlbegindialog: { 1423 ret = new TMssqlBeginDialog(vendor); 1424 break; 1425 } 1426 case sstmssqlsendonconversation: { 1427 ret = new TMssqlSendOnConversation(vendor); 1428 break; 1429 } 1430 case sstdropsequence: 1431 ret = new TDropSequenceStmt(vendor); 1432 break; 1433 case sstaltersequence: 1434 ret = new gudusoft.gsqlparser.stmt.TAlterSequenceStatement(vendor); 1435 break; 1436 case sstmssqldisabletrigger: 1437 case sstmssqlenabletrigger: { 1438 lcisnewsql = true; 1439 if (TBaseType.assigned(lccurrentsqlstatement)) { 1440 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) 1441 lcisnewsql = false; 1442 } 1443 1444 if (lcisnewsql) { 1445 ret = new TUnknownSqlStatement(vendor); 1446 ret.sqlstatementtype = gnewsqlstatementtype; 1447 } 1448 break; 1449 } 1450 case sstmssqlthrow: 1451 ret = new TMssqlThrow(vendor); 1452 break; 1453 case sstmssqlalterdatabase: 1454 ret = new TAlterDatabaseStmt(vendor); 1455 break; 1456 case sstmssqlreconfigure: 1457 ret = new TReconfigure(vendor); 1458 break; 1459 case sstcreatedatabase: { 1460 ret = new TCreateDatabaseSqlStatement(vendor); 1461 break; 1462 } 1463 case sstmssqlcreatedatabaseencryptionkey: { 1464 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1465 stub.sqlstatementtype = ESqlStatementType.sstmssqlcreatedatabaseencryptionkey; 1466 ret = stub; 1467 break; 1468 } 1469 case sstmssqlcreateselectivexmlindex: { 1470 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1471 stub.sqlstatementtype = ESqlStatementType.sstmssqlcreateselectivexmlindex; 1472 ret = stub; 1473 break; 1474 } 1475 case sstmssqlcreatejsonindex: { 1476 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1477 stub.sqlstatementtype = ESqlStatementType.sstmssqlcreatejsonindex; 1478 ret = stub; 1479 break; 1480 } 1481 case sstmssqlcreatevectorindex: { 1482 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1483 stub.sqlstatementtype = ESqlStatementType.sstmssqlcreatevectorindex; 1484 ret = stub; 1485 break; 1486 } 1487 case sstmssqlrenameobject: { 1488 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1489 stub.sqlstatementtype = ESqlStatementType.sstmssqlrenameobject; 1490 ret = stub; 1491 break; 1492 } 1493 case sstmssqlcreateremotetableasselect: { 1494 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1495 stub.sqlstatementtype = ESqlStatementType.sstmssqlcreateremotetableasselect; 1496 ret = stub; 1497 break; 1498 } 1499 case sstmssqlcreateschema: { 1500 ret = new TCreateSchemaSqlStatement(vendor); 1501 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 1502 lctoken = lcsourcetokenlist.get(k); 1503 if (lctoken.isnonsolidtoken()) continue; 1504 if (lctoken.tokencode == TBaseType.rrw_go) break; 1505 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 1506 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 1507 } 1508 break; 1509 } 1510 case sstmssqlcreatesynonym: { 1511 ret = new TCreateSynonymStmt(vendor); 1512 break; 1513 } 1514 case sstmssqlcreatetype: 1515 ret = new TMssqlCreateType(vendor); 1516 break; 1517 case sstmssqlcreatexmlschemacollection: 1518 ret = new TMssqlCreateXmlSchemaCollectionStmt(vendor); 1519 break; 1520 case sstmssqlalterindex: 1521 if (TBaseType.assigned(lccurrentsqlstatement) 1522 && lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) { 1523 ret = null; 1524 } else { 1525 ret = new TAlterIndexStmt(vendor); 1526 } 1527 break; 1528 case sstmssqlcreateevexternalDataSource: 1529 ret = new TCreateExternalDataSourceStmt(vendor); 1530 break; 1531 case sstmssqlcreateeventsession: 1532 ret = new TCreateEventSession(vendor); 1533 break; 1534 case sstmssqldropfunction: 1535 ret = new TDropFunctionStmt(vendor); 1536 break; 1537 case sstmssqlcreateevexternalLanguage: 1538 ret = new TCreateExternalLanguage(vendor); 1539 break; 1540 case sstmssqlalterview: { 1541 lcisnewsql = true; 1542 if (TBaseType.assigned(lccurrentsqlstatement)) { 1543 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 1544 lcisnewsql = false; 1545 } 1546 1547 if (lcisnewsql) { 1548 ret = new TAlterViewStatement(vendor); 1549 } 1550 break; 1551 } 1552 case sstCreateFileFormat: { 1553 ret = new TCreateFileFormatStmt(vendor); 1554 break; 1555 } 1556 case sstmssqlcreatemasterkey: 1557 ret = new TCreateMasterKeyStmt(vendor); 1558 break; 1559 case sstcreatecredential: 1560 ret = new TCreateCredentialStmt(vendor); 1561 break; 1562 case sstCopyInto: { 1563 ret = new TMssqlCopyIntoStmt(vendor); 1564 break; 1565 } 1566 case sstcreatematerializedview: { 1567 ret = new TCreateMaterializedSqlStatement(vendor); 1568 break; 1569 } 1570 case sstmssqlCreateSecurityPolicy: 1571 ret = new TMssqlCreateSecurityPolicy(vendor); 1572 break; 1573 case sstmssqlAlterSecurityPolicy: 1574 ret = new TMssqlAlterSecurityPolicy(vendor); 1575 break; 1576 case sstmssqlDropSecurityPolicy: 1577 ret = new TMssqlDropSecurityPolicy(vendor); 1578 break; 1579 case sstmssqlalterpartitionfunction: 1580 ret = new TAlterPartitionFunctionStmt(vendor); 1581 break; 1582 case sstmssqlcreatepartitionfunction: 1583 ret = new TCreatePartitionFunctionStmt(vendor); 1584 break; 1585 case sstmssqlalterpartitionscheme: 1586 ret = new TAlterPartitionSchemeSqlStatement(vendor); 1587 break; 1588 case sstmssqlcreatepartitionscheme: 1589 ret = new TCreatePartitionSchemeSqlStatement(vendor); 1590 break; 1591 case sstmssqlupdatestatistics: 1592 ret = new TMssqlUpdateStatistics(vendor); 1593 break; 1594 default: { 1595 ret = new TUnknownSqlStatement(vendor); 1596 ret.sqlstatementtype = gnewsqlstatementtype; 1597 break; 1598 } 1599 } 1600 return ret; 1601 } 1602 1603 1604}