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 227 // SQL Server admin DDL previously unrecognized (DROP kinds fell 228 // through to sstmssqlexec and were rejected with "Unknown object 229 // type in drop statement"; ALTER/CREATE kinds hit the splitter 230 // error path). All route to typed TUnknownSqlStatement. 231 addCmd(TBaseType.rrw_drop, "broker", "priority", ESqlStatementType.sstmssqladmindrop_brokerpriority); 232 addCmd(TBaseType.rrw_drop, "column", "encryption", "key", ESqlStatementType.sstmssqladmindrop_columnencryptionkey); 233 addCmd(TBaseType.rrw_drop, "column", "master", "key", ESqlStatementType.sstmssqladmindrop_columnmasterkey); 234 addCmd(TBaseType.rrw_drop, "cryptographic", "provider", ESqlStatementType.sstmssqladmindrop_cryptographicprovider); 235 addCmd(TBaseType.rrw_drop, "database", "audit", "specification", ESqlStatementType.sstmssqladmindrop_databaseauditspecification); 236 addCmd(TBaseType.rrw_drop, "database", "encryption", "key", ESqlStatementType.sstmssqladmindrop_databaseencryptionkey); 237 addCmd(TBaseType.rrw_drop, "external", "data", "source", ESqlStatementType.sstmssqladmindrop_externaldatasource); 238 addCmd(TBaseType.rrw_drop, "external", "file", "format", ESqlStatementType.sstmssqladmindrop_externalfileformat); 239 addCmd(TBaseType.rrw_drop, "external", "language", ESqlStatementType.sstmssqladmindrop_externallanguage); 240 addCmd(TBaseType.rrw_drop, "external", "library", ESqlStatementType.sstmssqladmindrop_externallibrary); 241 addCmd(TBaseType.rrw_drop, "external", "resource", "pool", ESqlStatementType.sstmssqladmindrop_externalresourcepool); 242 addCmd(TBaseType.rrw_drop, "external", "table", ESqlStatementType.sstmssqladmindrop_externaltable2); 243 addCmd(TBaseType.rrw_drop, "fulltext", "stoplist", ESqlStatementType.sstmssqladmindrop_fulltextstoplist); 244 addCmd(TBaseType.rrw_drop, "resource", "pool", ESqlStatementType.sstmssqladmindrop_resourcepool); 245 addCmd(TBaseType.rrw_drop, "search", "property", "list", ESqlStatementType.sstmssqladmindrop_searchpropertylist); 246 addCmd(TBaseType.rrw_drop, "sensitivity", "classification", ESqlStatementType.sstmssqladmindrop_sensitivityclassification); 247 addCmd(TBaseType.rrw_drop, "server", "audit", ESqlStatementType.sstmssqladmindrop_serveraudit); 248 addCmd(TBaseType.rrw_drop, "server", "audit", "specification", ESqlStatementType.sstmssqladmindrop_serverauditspecification); 249 addCmd(TBaseType.rrw_drop, "server", "role", ESqlStatementType.sstmssqladmindrop_serverrole); 250 addCmd(TBaseType.rrw_drop, "availability", "group", ESqlStatementType.sstmssqladmindrop_availabilitygroup); 251 addCmd(TBaseType.rrw_drop, "workload", "group", ESqlStatementType.sstmssqladmindrop_workloadgroup); 252 addCmd(TBaseType.rrw_alter, "availability", "group", ESqlStatementType.sstmssqladminalter_availabilitygroup); 253 addCmd(TBaseType.rrw_alter, "broker", "priority", ESqlStatementType.sstmssqladminalter_brokerpriority); 254 addCmd(TBaseType.rrw_alter, "column", "encryption", "key", ESqlStatementType.sstmssqladminalter_columnencryptionkey); 255 addCmd(TBaseType.rrw_alter, "cryptographic", "provider", ESqlStatementType.sstmssqladminalter_cryptographicprovider); 256 addCmd(TBaseType.rrw_alter, "event", "session", ESqlStatementType.sstmssqladminalter_eventsession); 257 addCmd(TBaseType.rrw_alter, "external", "data", "source", ESqlStatementType.sstmssqladminalter_externaldatasource); 258 addCmd(TBaseType.rrw_alter, "external", "language", ESqlStatementType.sstmssqladminalter_externallanguage); 259 addCmd(TBaseType.rrw_alter, "external", "library", ESqlStatementType.sstmssqladminalter_externallibrary); 260 addCmd(TBaseType.rrw_alter, "external", "resource", "pool", ESqlStatementType.sstmssqladminalter_externalresourcepool); 261 addCmd(TBaseType.rrw_alter, "fulltext", "stoplist", ESqlStatementType.sstmssqladminalter_fulltextstoplist); 262 addCmd(TBaseType.rrw_alter, "resource", "governor", ESqlStatementType.sstmssqladminalter_resourcegovernor); 263 addCmd(TBaseType.rrw_alter, "resource", "pool", ESqlStatementType.sstmssqladminalter_resourcepool); 264 addCmd(TBaseType.rrw_alter, "search", "property", "list", ESqlStatementType.sstmssqladminalter_searchpropertylist); 265 addCmd(TBaseType.rrw_alter, "server", "audit", ESqlStatementType.sstmssqladminalter_serveraudit); 266 addCmd(TBaseType.rrw_alter, "server", "audit", "specification", ESqlStatementType.sstmssqladminalter_serverauditspecification); 267 addCmd(TBaseType.rrw_alter, "server", "configuration", ESqlStatementType.sstmssqladminalter_serverconfiguration); 268 addCmd(TBaseType.rrw_alter, "server", "role", ESqlStatementType.sstmssqladminalter_serverrole); 269 addCmd(TBaseType.rrw_alter, "workload", "group", ESqlStatementType.sstmssqladminalter_workloadgroup); 270 addCmd(TBaseType.rrw_create, "broker", "priority", ESqlStatementType.sstmssqladmincreate_brokerpriority); 271 addCmd(TBaseType.rrw_create, "cryptographic", "provider", ESqlStatementType.sstmssqladmincreate_cryptographicprovider); 272 addCmd(TBaseType.rrw_create, "external", "library", ESqlStatementType.sstmssqladmincreate_externallibrary); 273 addCmd(TBaseType.rrw_create, "external", "resource", "pool", ESqlStatementType.sstmssqladmincreate_externalresourcepool); 274 addCmd(TBaseType.rrw_create, "fulltext", "stoplist", ESqlStatementType.sstmssqladmincreate_fulltextstoplist); 275 addCmd(TBaseType.rrw_create, "search", "property", "list", ESqlStatementType.sstmssqladmincreate_searchpropertylist); 276 addCmd(TBaseType.rrw_create, "server", "role", ESqlStatementType.sstmssqladmincreate_serverrole); 277 addCmd(TBaseType.rrw_get, "conversation", "group", ESqlStatementType.sstmssqlgetconversationgroup); 278 addCmd(TBaseType.rrw_drop, "application", "role", ESqlStatementType.sstmssqldropapplicationrole); 279 addCmd(TBaseType.rrw_drop, "assembly", ESqlStatementType.sstmssqldropassembly); 280 addCmd(TBaseType.rrw_drop, "asymmetric", "key", ESqlStatementType.sstmssqldropasymmetrickey); 281 addCmd(TBaseType.rrw_drop, "certificate", ESqlStatementType.sstmssqldropcertificate); 282 addCmd(TBaseType.rrw_drop, "contract", ESqlStatementType.sstmssqldropcontract); 283 addCmd(TBaseType.rrw_drop, "counter", "signature", ESqlStatementType.sstmssqldropsignature); 284 addCmd(TBaseType.rrw_drop, "credential", ESqlStatementType.sstmssqldropcredential); 285 addCmd(TBaseType.rrw_drop, "database", ESqlStatementType.sstmssqldropdatabase); 286 addCmd(TBaseType.rrw_drop, "default", ESqlStatementType.sstmssqldropdefault); 287 addCmd(TBaseType.rrw_drop, "endpoint", ESqlStatementType.sstmssqldropendpoint); 288 addCmd(TBaseType.rrw_drop, "event", "notification", ESqlStatementType.sstmssqldropeventnotification); 289 addCmd(TBaseType.rrw_drop, "event", "session", ESqlStatementType.sstmssqldropeventsession); 290 addCmd(TBaseType.rrw_drop, "fulltext", "catalog", ESqlStatementType.sstmssqldropfulltextcatalog); 291 addCmd(TBaseType.rrw_drop, "fulltext", "index", ESqlStatementType.sstmssqldropfulltextindex); 292 addCmd(TBaseType.rrw_drop, "function", ESqlStatementType.sstmssqldropfunction); 293 addCmd(TBaseType.rrw_drop, "index", ESqlStatementType.sstmssqldropindex); 294 addCmd(TBaseType.rrw_drop, "login", ESqlStatementType.sstmssqldroplogin); 295 addCmd(TBaseType.rrw_drop, "master", "key", ESqlStatementType.sstmssqldropmasterkey); 296 addCmd(TBaseType.rrw_drop, "message", "type", ESqlStatementType.sstmssqldropmessagetype); 297 addCmd(TBaseType.rrw_drop, "partition", "function", ESqlStatementType.sstmssqldroppartitionfunction); 298 addCmd(TBaseType.rrw_drop, "partition", "scheme", ESqlStatementType.sstmssqldroppartitionscheme); 299 addCmd(TBaseType.rrw_drop, "proc", ESqlStatementType.sstmssqldropprocedure); 300 addCmd(TBaseType.rrw_drop, "procedure", ESqlStatementType.sstmssqldropprocedure); 301 addCmd(TBaseType.rrw_drop, "queue", ESqlStatementType.sstmssqldropqueue); 302 addCmd(TBaseType.rrw_drop, "remote", "service", "binding", ESqlStatementType.sstmssqldropremoteservicebinding); 303 addCmd(TBaseType.rrw_drop, "role", ESqlStatementType.sstmssqldroprole); 304 addCmd(TBaseType.rrw_drop, "route", ESqlStatementType.sstmssqldroproute); 305 addCmd(TBaseType.rrw_drop, "rule", ESqlStatementType.sstmssqldroprule); 306 addCmd(TBaseType.rrw_drop, "schema", ESqlStatementType.sstmssqldropschema); 307 addCmd(TBaseType.rrw_drop, "security", "policy", ESqlStatementType.sstmssqlDropSecurityPolicy); 308 addCmd(TBaseType.rrw_drop, "sequence", ESqlStatementType.sstdropsequence); 309 addCmd(TBaseType.rrw_drop, "service", ESqlStatementType.sstmssqldropservice); 310 addCmd(TBaseType.rrw_drop, "signature", ESqlStatementType.sstmssqldropsignature); 311 addCmd(TBaseType.rrw_drop, "statistics", ESqlStatementType.sstmssqldropstatistics); 312 addCmd(TBaseType.rrw_drop, "symmetric", "key", ESqlStatementType.sstmssqldropsymmetrickey); 313 addCmd(TBaseType.rrw_drop, "synonym", ESqlStatementType.sstmssqldropsynonym); 314 addCmd(TBaseType.rrw_drop, "table", ESqlStatementType.sstmssqldroptable); 315 addCmd(TBaseType.rrw_drop, "trigger", ESqlStatementType.sstmssqldroptrigger); 316 addCmd(TBaseType.rrw_drop, "type", ESqlStatementType.sstmssqldroptype); 317 addCmd(TBaseType.rrw_drop, "user", ESqlStatementType.sstmssqldropuser); 318 addCmd(TBaseType.rrw_drop, "view", ESqlStatementType.sstmssqldropview); 319 addCmd(TBaseType.rrw_drop, "xml", "schema", "collection", ESqlStatementType.sstmssqldropxmlschemacollection); 320 321 // ENABLE TRIGGER 322 addCmd(TBaseType.rrw_enable, "trigger", ESqlStatementType.sstmssqlenabletrigger); 323 324 // END CONVERSATION 325 addCmd(TBaseType.rrw_end, "conversation", ESqlStatementType.sstmssqlendconversation); 326 327 // EXEC/EXECUTE commands 328 addCmd(TBaseType.rrw_exec, ESqlStatementType.sstmssqlexec); 329 addCmd(TBaseType.rrw_exec, "as", "caller", ESqlStatementType.sstmssqlexecuteas); 330 addCmd(TBaseType.rrw_exec, "as", "login", ESqlStatementType.sstmssqlexecuteas); 331 addCmd(TBaseType.rrw_exec, "as", "user", ESqlStatementType.sstmssqlexecuteas); 332 addCmd(TBaseType.rrw_execute, ESqlStatementType.sstmssqlexec); 333 addCmd(TBaseType.rrw_execute, "as", "caller", ESqlStatementType.sstmssqlexecuteas); 334 addCmd(TBaseType.rrw_execute, "as", "login", ESqlStatementType.sstmssqlexecuteas); 335 addCmd(TBaseType.rrw_execute, "as", "user", ESqlStatementType.sstmssqlexecuteas); 336 337 // FETCH 338 addCmd(TBaseType.rrw_fetch, ESqlStatementType.sstmssqlfetch); 339 340 // GO 341 addCmd(TBaseType.rrw_go, ESqlStatementType.sstmssqlgo); 342 343 // GOTO 344 addCmd(TBaseType.rrw_goto, ESqlStatementType.sstmssqlgoto); 345 346 // GRANT 347 addCmd(TBaseType.rrw_grant, ESqlStatementType.sstmssqlgrant); 348 349 // IF 350 addCmd(TBaseType.rrw_if, ESqlStatementType.sstmssqlif); 351 352 // INSERT 353 addCmd(TBaseType.rrw_insert, ESqlStatementType.sstinsert); 354 addCmd(TBaseType.rrw_insert, "bulk", ESqlStatementType.sstmssqlinsertbulk); 355 356 // KILL commands 357 addCmd(TBaseType.rrw_kill, ESqlStatementType.sstmssqlkill); 358 addCmd(TBaseType.rrw_kill, "kill", "query", "notification", "subscription", ESqlStatementType.sstmssqlkillquerynotificationsubscription); 359 addCmd(TBaseType.rrw_kill, "stats", ESqlStatementType.sstmssqlkillstats); 360 361 // LOCK TABLE 362 addCmd(TBaseType.rw_locktable, "table", ESqlStatementType.sstsybaselocktable); 363 364 // MOVE CONVERSATION 365 addCmd(TBaseType.rrw_move, "conversation", ESqlStatementType.sstmssqlmoveconversation); 366 367 // MERGE 368 addCmd(TBaseType.rrw_merge, ESqlStatementType.sstmerge); 369 370 // OPEN commands 371 addCmd(TBaseType.rrw_open, ESqlStatementType.sstmssqlopen); 372 addCmd(TBaseType.rrw_open, "master", "key", ESqlStatementType.sstmssqlopenmasterkey); 373 addCmd(TBaseType.rrw_open, "symmetric", "key", ESqlStatementType.sstmssqlopensymmetrickey); 374 375 // PRINT 376 addCmd(TBaseType.rrw_print, ESqlStatementType.sstmssqlprint); 377 378 // RAISERROR 379 addCmd(TBaseType.rrw_raiserror, ESqlStatementType.sstmssqlraiserror); 380 381 // READTEXT 382 addCmd(TBaseType.rrw_readtext, ESqlStatementType.sstmssqlreadtext); 383 384 // RECEIVE 385 addCmd(TBaseType.rrw_receive, ESqlStatementType.sstmssqlreceive); 386 387 // RECONFIGURE 388 addCmd(TBaseType.rrw_reconfigure, ESqlStatementType.sstmssqlreconfigure); 389 390 // RENAME 391 addCmd(TBaseType.rrw_rename, "object", ESqlStatementType.sstmssqlrenameobject); 392 393 // RESTORE commands 394 addCmd(TBaseType.rrw_restore, "database", ESqlStatementType.sstmssqlrestoredatabase); 395 addCmd(TBaseType.rrw_restore, "filelistonly", ESqlStatementType.sstmssqlrestorefilelistonly); 396 addCmd(TBaseType.rrw_restore, "headeronly", ESqlStatementType.sstmssqlrestoreheaderonly); 397 addCmd(TBaseType.rrw_restore, "labelonly", ESqlStatementType.sstmssqlrestorelabelonly); 398 addCmd(TBaseType.rrw_restore, "log", ESqlStatementType.sstmssqlrestorelog); 399 addCmd(TBaseType.rrw_restore, "master", "key", ESqlStatementType.sstmssqlrestoremasterkey); 400 addCmd(TBaseType.rrw_restore, "rewindonly", ESqlStatementType.sstmssqlrestorerewindonly); 401 addCmd(TBaseType.rrw_restore, "service", "master", "key", ESqlStatementType.sstmssqlrestoreservicemasterkey); 402 addCmd(TBaseType.rrw_restore, "verifyonly", ESqlStatementType.sstmssqlrestoreverifyonly); 403 404 // RETURN 405 addCmd(TBaseType.rrw_return, ESqlStatementType.sstmssqlreturn); 406 407 // REVERT 408 addCmd(TBaseType.rrw_revert, ESqlStatementType.sstmssqlrevert); 409 410 // REVOKE 411 addCmd(TBaseType.rrw_revoke, ESqlStatementType.sstmssqlrevoke); 412 413 // ROLLBACK commands 414 addCmd(TBaseType.rrw_rollback, ESqlStatementType.sstmssqlrollback); 415 addCmd(TBaseType.rrw_rollback, "tran", ESqlStatementType.sstmssqlrollback); 416 addCmd(TBaseType.rrw_rollback, "transaction", ESqlStatementType.sstmssqlrollback); 417 addCmd(TBaseType.rrw_rollback, "work", ESqlStatementType.sstmssqlrollback); 418 419 // SAVE commands 420 addCmd(TBaseType.rrw_save, ESqlStatementType.sstmssqlsavetran); 421 addCmd(TBaseType.rrw_save, "tran", ESqlStatementType.sstmssqlsavetran); 422 addCmd(TBaseType.rrw_save, "transaction", ESqlStatementType.sstmssqlsavetran); 423 424 // SELECT 425 addCmd(TBaseType.rrw_select, ESqlStatementType.sstselect); 426 427 // SEND ON CONVERSATION 428 addCmd(TBaseType.rrw_send, "on", "conversation", ESqlStatementType.sstmssqlsendonconversation); 429 430 // SET commands 431 addCmd(TBaseType.rrw_set, ESqlStatementType.sstmssqlset); 432 addCmd(TBaseType.rrw_set, "rowcount", ESqlStatementType.sstmssqlsetrowcount); 433 434 // SETUSER 435 addCmd(TBaseType.rrw_setuser, ESqlStatementType.sstmssqlsetuser); 436 437 // SHUTDOWN 438 addCmd(TBaseType.rrw_shutdown, ESqlStatementType.sstmssqlshutdown); 439 440 // THROW 441 addCmd(TBaseType.rrw_sqlserver_throw, ESqlStatementType.sstmssqlthrow); 442 443 // TRUNCATE TABLE 444 addCmd(TBaseType.rrw_truncate, "table", ESqlStatementType.sstmssqltruncatetable); 445 446 // UPDATE commands 447 addCmd(TBaseType.rrw_update, ESqlStatementType.sstupdate); 448 addCmd(TBaseType.rrw_update, "statistics", ESqlStatementType.sstmssqlupdatestatistics); 449 450 // UPDATETEXT 451 addCmd(TBaseType.rrw_updatetext, ESqlStatementType.sstmssqlupdatetext); 452 453 // USE 454 addCmd(TBaseType.rrw_use, ESqlStatementType.sstmssqluse); 455 456 // WAITFOR 457 addCmd(TBaseType.rrw_waitfor, ESqlStatementType.sstmssqlwaitfor); 458 459 // WHILE 460 addCmd(TBaseType.rrw_while, ESqlStatementType.sstmssqlwhile); 461 462 // WRITETEXT 463 addCmd(TBaseType.rrw_writetext, ESqlStatementType.sstmssqlwritetext); 464 } 465 466 @Override 467 public ESqlStatementType getStatementTypeForToken(TSourceToken token) { 468 ESqlStatementType ret = ESqlStatementType.sstinvalid; 469 470 int lcpos = token.posinlist; 471 TSourceTokenList lcsourcetokenlist = token.container; 472 473 // Subquery after semicolon or at first line 474 if (token.tokentype == ETokenType.ttleftparenthesis) { // ( 475 int k = lcsourcetokenlist.solidtokenafterpos(lcpos, TBaseType.rrw_select, 1, "("); 476 if (k > 0) { 477 ret = ESqlStatementType.sstselect; 478 } 479 return ret; 480 } 481 482 ret = super.getStatementTypeForToken (token); 483 // Execute can't be used to delimit other SQL 484 if (ret == ESqlStatementType.sstmssqlexec) { 485 ret = ESqlStatementType.sstinvalid; 486 } 487 488 return ret; 489 } 490 491 @Override 492 public TCustomSqlStatement issql(TSourceToken token, EFindSqlStateType state, TCustomSqlStatement currentStatement) { 493 TCustomSqlStatement ret = null; 494 int k; 495 boolean lcisnewsql; 496 TSourceToken lcpprevsolidtoken, lcnextsolidtoken, lctoken; 497 498 gnewsqlstatementtype = ESqlStatementType.sstinvalid; 499 500 if ((token.tokencode == TBaseType.cmtdoublehyphen) 501 || (token.tokencode == TBaseType.cmtslashstar) 502 || (token.tokencode == TBaseType.lexspace) 503 || (token.tokencode == TBaseType.lexnewline) 504 || (token.tokentype == ETokenType.ttsemicolon)) { 505 return ret; 506 } 507 508 int lcpos = token.posinlist; 509 TSourceTokenList lcsourcetokenlist = token.container; 510 TCustomSqlStatement lccurrentsqlstatement = currentStatement; 511 512 // GET CONVERSATION GROUP: GET is a plain identifier in the lexer, so 513 // the keyword-driven command table can never match it. Recognize the 514 // three-word head textually at statement-start position. 515 if ((state == EFindSqlStateType.stnormal) 516 && (token.tokentype == ETokenType.ttidentifier) 517 && token.toString().equalsIgnoreCase("GET")) { 518 TSourceToken t1 = token.nextSolidToken(); 519 if ((t1 != null) && t1.toString().equalsIgnoreCase("CONVERSATION")) { 520 TSourceToken t2 = t1.nextSolidToken(); 521 if ((t2 != null) && t2.toString().equalsIgnoreCase("GROUP")) { 522 ret = new TUnknownSqlStatement(this.vendor); 523 ret.sqlstatementtype = ESqlStatementType.sstmssqlgetconversationgroup; 524 gnewsqlstatementtype = ESqlStatementType.sstmssqlgetconversationgroup; 525 return ret; 526 } 527 } 528 } 529 530 // Subquery after semicolon or at first line 531 if (token.tokentype == ETokenType.ttleftparenthesis) { // ( 532 k = lcsourcetokenlist.solidtokenafterpos(lcpos, TBaseType.rrw_select, 1, "("); 533 if (k > 0) { 534 if (state == EFindSqlStateType.stnormal) { 535 ret = new TSelectSqlStatement(vendor); 536 return ret; 537 } 538 } 539 } 540 541 // CTE 542 if ((state == EFindSqlStateType.stnormal) && (token.tokencode == TBaseType.rrw_with)) { 543 ret = findcte(token); 544 if ((ret != null)) return ret; 545 } 546 547 // CTE starting without semicolon after previous DML statement 548 if ((state != EFindSqlStateType.stnormal) && (token.tokencode == TBaseType.rrw_with) 549 && lccurrentsqlstatement != null 550 && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect 551 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstupdate 552 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdelete)) { 553 TSourceToken nextSolid = token.nextSolidToken(); 554 // WITH followed by ( is a table hint, not a CTE; require WITH <name> AS pattern 555 if (nextSolid != null && nextSolid.tokentype != ETokenType.ttleftparenthesis) { 556 TSourceToken afterName = nextSolid.nextSolidToken(); 557 if (afterName != null && (afterName.tokencode == TBaseType.rrw_as 558 || afterName.tokentype == ETokenType.ttleftparenthesis)) { 559 ret = findcte(token); 560 if (ret != null) return ret; 561 } 562 } 563 } 564 565 if ((lccurrentsqlstatement != null) && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 566 && (token.tokencode == TBaseType.rrw_with)) { 567 TSourceToken lcPrevToken = token.prevSolidToken(); 568 if ((lcPrevToken != null) && (lcPrevToken.tokencode == TBaseType.rrw_as)) { 569 // mantisbt/view.php?id=3900, create table with as select, ignore tokens from with to select 570 ret = findcte(token); 571 if ((ret != null)) { 572 ret = null; 573 } 574 } 575 } 576 577 // ODBC 578 if ((state == EFindSqlStateType.stnormal) && ((token.tokencode == '{') || (token.tokencode == TBaseType.odbc_esc_prefix)) && (token.getLinkToken() != null)) { 579 ret = new TCallStatement(vendor); 580 return ret; 581 } 582 583 gnewsqlstatementtype = super.getStatementTypeForToken(token); 584 585 // Don't split inside stub-like statements - they consume everything until semicolon 586 if (state != EFindSqlStateType.stnormal && lccurrentsqlstatement != null 587 && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlstmtstub 588 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateserveraudit 589 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatedatabaseauditspecification) 590 && gnewsqlstatementtype != ESqlStatementType.sstinvalid) { 591 gnewsqlstatementtype = ESqlStatementType.sstinvalid; 592 return ret; 593 } 594 595 TSourceToken lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 596 switch (gnewsqlstatementtype) { 597 case sstinvalid: { 598 if (token.tokencode == TBaseType.mslabel) { 599 ret = new TMssqlLabel(vendor); 600 } else 601 ret = null; 602 break; 603 } 604 case sstselect: { 605 lcisnewsql = true; 606 607 if (state != EFindSqlStateType.stnormal) { 608 if ((lcprevsolidtoken != null)) { 609 if (lcprevsolidtoken.tokentype == ETokenType.ttleftparenthesis) 610 lcisnewsql = false; // subquery 611 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_union) 612 lcisnewsql = false; 613 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_intersect) 614 lcisnewsql = false; 615 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_minus) 616 lcisnewsql = false; 617 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_except) 618 lcisnewsql = false; 619 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_return) 620 lcisnewsql = false; 621 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_as) { 622 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 623 lcisnewsql = false; 624 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 625 lcisnewsql = false; 626 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatematerializedview) 627 lcisnewsql = false; 628 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstalterview) 629 lcisnewsql = false; 630 } else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) { 631 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlset) 632 lcisnewsql = false; 633 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqldeclare) 634 lcisnewsql = false; 635 } 636 637 if (lcisnewsql && (lcprevsolidtoken.tokencode == TBaseType.rrw_all)) { 638 lcpprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcprevsolidtoken.posinlist); 639 if ((lcpprevsolidtoken != null)) { 640 if (lcpprevsolidtoken.tokencode == TBaseType.rrw_union) 641 lcisnewsql = false; 642 } 643 } 644 } 645 646 if ((lccurrentsqlstatement != null)) { 647 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 648 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 649 if ((lcprevsolidtoken != null)) { 650 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 651 lcisnewsql = false; 652 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 653 lcisnewsql = false; 654 } 655 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview 656 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatematerializedview 657 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstalterview) { 658 // In CREATE VIEW / ALTER VIEW, SELECT is part of the view body when 659 // preceded by the ')' of a WITH-clause item (CTE anchor query: 660 // WITH cte AS (...) SELECT, or WITH XMLNAMESPACES (...) SELECT). 661 // Other continuation cases (AS, UNION, UNION ALL, INTERSECT, EXCEPT, 662 // subquery) are already handled by the earlier checks above. A ')' 663 // closing anything else — a table hint WITH (NOLOCK), a named window 664 // WINDOW w AS (...), a derived table — ends a complete view body, 665 // and the SELECT after it starts a new statement. 666 if (lcprevsolidtoken != null 667 && lcprevsolidtoken.tokentype == ETokenType.ttrightparenthesis 668 && closesWithClauseItem(lcprevsolidtoken)) { 669 lcisnewsql = false; 670 } 671 } 672 } 673 } 674 675 if (lcisnewsql) 676 ret = new TSelectSqlStatement(vendor); 677 break; 678 } 679 case sstinsert: { 680 lcisnewsql = true; 681 if (state != EFindSqlStateType.stnormal) { 682 if ((lccurrentsqlstatement != null)) { 683 // merge 684 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 685 if (lcprevsolidtoken != null) { 686 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 687 lcisnewsql = false; 688 } 689 } 690 } 691 692 // bulk insert 693 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlbulkinsert) { 694 if ((lcprevsolidtoken != null)) { 695 if (lcprevsolidtoken.tokencode == TBaseType.rrw_bulk) 696 lcisnewsql = false; 697 } 698 } 699 700 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 701 if ((lcprevsolidtoken != null)) { 702 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 703 lcisnewsql = false; 704 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 705 lcisnewsql = false; 706 } 707 } 708 709 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger 710 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) { 711 if ((lcprevsolidtoken != null)) { 712 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 713 lcisnewsql = false; 714 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 715 lcisnewsql = false; 716 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 717 lcisnewsql = false; 718 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 719 lcisnewsql = false; 720 } 721 } 722 723 // CREATE SECURITY POLICY ... AFTER INSERT 724 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlCreateSecurityPolicy) { 725 if ((lcprevsolidtoken != null)) { 726 if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 727 lcisnewsql = false; 728 } 729 } 730 } 731 } 732 733 if (lcisnewsql) { 734 ret = new TInsertSqlStatement(vendor); 735 ret.dummytag = 1; // select stmt in insert is permitted 736 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 737 if (lcsourcetokenlist.get(k).isnonsolidtoken()) continue; 738 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_values) break; 739 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_go) break; 740 if (lcsourcetokenlist.get(k).tokentype == ETokenType.ttsemicolon) break; 741 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_select) { 742 ret.dummytag = 0; 743 break; 744 } 745 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_execute) break; 746 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_exec) break; 747 } 748 if (k > lcsourcetokenlist.size() - 1) 749 k = lcsourcetokenlist.size() - 1; 750 751 for (int i = lcpos + 1; i <= k; i++) { 752 lcsourcetokenlist.get(i).tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 753 } 754 } 755 break; 756 } 757 case sstupdate: { 758 lcisnewsql = true; 759 if (state != EFindSqlStateType.stnormal) { 760 if ((lcprevsolidtoken != null)) { 761 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 762 lcisnewsql = false; 763 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 764 lcisnewsql = false; 765 } 766 767 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 768 if (TBaseType.assigned(lcnextsolidtoken)) { 769 if (lcnextsolidtoken.tokentype == ETokenType.ttleftparenthesis) { 770 k = lcsourcetokenlist.solidtokenafterpos(lcnextsolidtoken.posinlist, TBaseType.rrw_select, 1, "("); 771 if (k == 0) lcisnewsql = false; 772 } 773 } 774 775 if (TBaseType.assigned(lccurrentsqlstatement)) { 776 // merge 777 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 778 if (lcprevsolidtoken != null) { 779 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 780 lcisnewsql = false; 781 } 782 } 783 } 784 785 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 786 if (TBaseType.assigned(lcprevsolidtoken)) { 787 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 788 lcisnewsql = false; 789 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 790 lcisnewsql = false; 791 } 792 } 793 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger 794 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) { 795 if (TBaseType.assigned(lcprevsolidtoken)) { 796 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 797 lcisnewsql = false; 798 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 799 lcisnewsql = false; 800 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 801 lcisnewsql = false; 802 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 803 lcisnewsql = false; 804 } 805 } 806 807 // CREATE SECURITY POLICY ... AFTER UPDATE / BEFORE UPDATE 808 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlCreateSecurityPolicy) { 809 if (TBaseType.assigned(lcprevsolidtoken)) { 810 if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 811 lcisnewsql = false; 812 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "before") == 0) 813 lcisnewsql = false; 814 } 815 } 816 } 817 } 818 819 if (lcisnewsql) { 820 ret = new TUpdateSqlStatement(vendor); 821 ret.dummytag = 1; // means set clause in update is not found yet 822 } 823 break; 824 } 825 case sstdelete: { 826 lcisnewsql = true; 827 828 if (state != EFindSqlStateType.stnormal) { 829 lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 830 if (TBaseType.assigned(lcprevsolidtoken)) { 831 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 832 lcisnewsql = false; 833 } 834 835 if (TBaseType.assigned(lccurrentsqlstatement)) { 836 // merge 837 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 838 if (lcprevsolidtoken != null) { 839 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 840 lcisnewsql = false; 841 } 842 } 843 } 844 845 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 846 if (TBaseType.assigned(lcprevsolidtoken)) { 847 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 848 lcisnewsql = false; 849 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 850 lcisnewsql = false; 851 } 852 } 853 854 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger 855 || lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) { 856 if (TBaseType.assigned(lcprevsolidtoken)) { 857 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 858 lcisnewsql = false; 859 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 860 lcisnewsql = false; 861 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 862 lcisnewsql = false; 863 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 864 lcisnewsql = false; 865 } 866 } 867 868 // CREATE SECURITY POLICY ... BEFORE DELETE 869 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlCreateSecurityPolicy) { 870 if (TBaseType.assigned(lcprevsolidtoken)) { 871 if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "before") == 0) 872 lcisnewsql = false; 873 } 874 } 875 } 876 } 877 878 if (lcisnewsql) 879 ret = new TDeleteSqlStatement(vendor); 880 break; 881 } 882 case sstcreatetable: { 883 lcisnewsql = true; 884 if (state != EFindSqlStateType.stnormal) { 885 if (TBaseType.assigned(lccurrentsqlstatement)) { 886 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 887 lcisnewsql = false; 888 } 889 } 890 } 891 892 if (lcisnewsql) { 893 ret = new TCreateTableSqlStatement(vendor); 894 } 895 break; 896 } 897 case sstcreateview: { 898 lcisnewsql = true; 899 if (state != EFindSqlStateType.stnormal) { 900 if (TBaseType.assigned(lccurrentsqlstatement)) { 901 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 902 lcisnewsql = false; 903 } 904 } 905 } 906 if (lcisnewsql) { 907 ret = new TCreateViewSqlStatement(vendor); 908 } 909 break; 910 } 911 case sstcreatesequence: { 912 ret = new TCreateSequenceStmt(vendor); 913 break; 914 } 915 case sstaltertable: { 916 ret = new TAlterTableStatement(vendor); 917 break; 918 } 919 case sstmssqlfetch: { 920 ret = new TMssqlFetch(vendor); 921 break; 922 } 923 case sstmssqlif: { 924 lcisnewsql = true; 925 if (state != EFindSqlStateType.stnormal) { 926 if (TBaseType.assigned(lccurrentsqlstatement)) { 927 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropprocedure) 928 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropdatabase) 929 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropfunction) 930 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlDropSecurityPolicy)) { 931 lcisnewsql = false; 932 } else if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdroptable) 933 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropindex) 934 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 935 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropsynonym) 936 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropview) 937 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdropsequence) 938 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqldroptrigger)) { 939 // DROP TABLE IF EXISTS T1; 940 TSourceToken st = lcsourcetokenlist.solidtokenbefore(lcpos); 941 if ((st.tokencode == TBaseType.rrw_table) || (st.tokencode == TBaseType.rrw_index) 942 || (st.tokencode == TBaseType.rrw_sqlserver_synonym) || (st.tokencode == TBaseType.rrw_view) 943 || (st.tokencode == TBaseType.rrw_sqlserver_sequence) || (st.toString().equalsIgnoreCase("trigger"))) { 944 lcisnewsql = false; 945 } 946 } else if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable)) { 947 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 948 if (lcnextsolidtoken != null) { 949 if (lcnextsolidtoken.tokencode == TBaseType.rrw_sqlserver_exists) { 950 lcisnewsql = false; 951 } 952 } 953 } 954 } 955 } 956 957 if (lcisnewsql) { 958 ret = new TMssqlIfElse(vendor); 959 ret.dummytag = 1; // reduce to 0 while stmt find in 'if (condition stmt' || 'else stmt' 960 } 961 break; 962 } 963 case sstmssqlwhile: { 964 ret = new TMssqlIfElse(vendor); 965 ret.sqlstatementtype = ESqlStatementType.sstmssqlwhile; 966 ret.dummytag = 1; // reduce to 0 while stmt find in 'if (condition stmt' || 'else stmt' 967 break; 968 } 969 case sstmssqlcreateprocedure: 970 case sstmssqlalterprocedure: { 971 ret = new TMssqlCreateProcedure(vendor); 972 if (gnewsqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) { 973 ret.sqlstatementtype = ESqlStatementType.sstmssqlalterprocedure; 974 } 975 break; 976 } 977 case sstmssqlcreatefunction: 978 case sstmssqlalterfunction: { 979 ret = new TMssqlCreateFunction(vendor); 980 if (gnewsqlstatementtype == ESqlStatementType.sstmssqlalterfunction) { 981 ret.sqlstatementtype = ESqlStatementType.sstmssqlalterfunction; 982 } 983 break; 984 } 985 case sstcreatetrigger: 986 case sstmssqlaltertrigger: { 987 ret = new TCreateTriggerStmt(vendor); 988 if (gnewsqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) { 989 ret.sqlstatementtype = ESqlStatementType.sstmssqlaltertrigger; 990 } 991 break; 992 } 993 case sstmssqlreturn: { 994 ret = new TMssqlReturn(vendor); 995 break; 996 } 997 case sstmssqlprint: { 998 if (vendor == EDbVendor.dbvodbc) { 999 } else if (vendor == EDbVendor.dbvmssql) { 1000 ret = new TMssqlPrint(vendor); 1001 } 1002 break; 1003 } 1004 case sstmssqluse: { 1005 lcisnewsql = true; 1006 if (state != EFindSqlStateType.stnormal) { 1007 if (TBaseType.assigned(lcprevsolidtoken)) { 1008 // USE HINT inside OPTION clause: prev token is comma or left paren 1009 if (lcprevsolidtoken.tokentype == ETokenType.ttcomma 1010 || lcprevsolidtoken.tokentype == ETokenType.ttleftparenthesis) { 1011 lcisnewsql = false; 1012 } 1013 } 1014 } 1015 if (lcisnewsql) { 1016 ret = new TUseDatabase(vendor); 1017 } 1018 break; 1019 } 1020 case sstmssqlgo: { 1021 ret = new TMssqlGo(vendor); 1022 break; 1023 } 1024 case sstmssqlrevert: { 1025 lcisnewsql = true; 1026 // prev tokentext can't be with 1027 if (state != EFindSqlStateType.stnormal) { 1028 if (TBaseType.assigned(lcprevsolidtoken)) { 1029 if (lcprevsolidtoken.toString().equalsIgnoreCase("no")) { 1030 ret = null; 1031 lcisnewsql = false; 1032 } 1033 } 1034 } 1035 if (lcisnewsql) { 1036 ret = new TMssqlRevert(vendor); 1037 } 1038 break; 1039 } 1040 case sstmssqlgrant: { 1041 lcisnewsql = true; 1042 // prev tokentext can't be with 1043 if (state != EFindSqlStateType.stnormal) { 1044 if (TBaseType.assigned(lcprevsolidtoken)) { 1045 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) { 1046 ret = null; 1047 lcisnewsql = false; 1048 } 1049 } 1050 1051 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 1052 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 1053 lcisnewsql = false; 1054 } 1055 } 1056 } 1057 if (lcisnewsql) { 1058 ret = new TGrantStmt(vendor); 1059 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 1060 lctoken = lcsourcetokenlist.get(k); 1061 if (lctoken.isnonsolidtoken()) continue; 1062 if (lctoken.tokencode == TBaseType.rrw_go) break; 1063 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 1064 if (lctoken.tokencode == TBaseType.rrw_to) break; 1065 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 1066 } 1067 } 1068 break; 1069 } 1070 case sstmssqlrevoke: { 1071 lcisnewsql = true; 1072 if (state != EFindSqlStateType.stnormal) { 1073 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 1074 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 1075 lcisnewsql = false; 1076 } 1077 } 1078 } 1079 if (lcisnewsql) { 1080 ret = new TRevokeStmt(vendor); 1081 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 1082 lctoken = lcsourcetokenlist.get(k); 1083 if (lctoken.isnonsolidtoken()) continue; 1084 if (lctoken.tokencode == TBaseType.rrw_go) break; 1085 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 1086 if (lctoken.tokencode == TBaseType.rrw_to) break; 1087 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 1088 } 1089 } 1090 break; 1091 } 1092 case sstmssqldeny: { 1093 lcisnewsql = true; 1094 if (state != EFindSqlStateType.stnormal) { 1095 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 1096 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateschema)) { 1097 lcisnewsql = false; 1098 } 1099 } 1100 } 1101 if (lcisnewsql) { 1102 ret = new TDenyStmt(vendor); 1103 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 1104 lctoken = lcsourcetokenlist.get(k); 1105 if (lctoken.isnonsolidtoken()) continue; 1106 if (lctoken.tokencode == TBaseType.rrw_go) break; 1107 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 1108 if (lctoken.tokencode == TBaseType.rrw_to) break; 1109 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 1110 } 1111 } 1112 break; 1113 } 1114 case sstmssqldeclare: { 1115 ret = new TMssqlDeclare(vendor); 1116 break; 1117 } 1118 case sstmssqlcontinue: { 1119 ret = new TMssqlContinue(vendor); 1120 break; 1121 } 1122 case sstbreak: { 1123 ret = new TBreakStmt(vendor); 1124 break; 1125 } 1126 case sstmssqlopen: { 1127 ret = new TMssqlOpen(vendor); 1128 break; 1129 } 1130 case sstmssqlclose: { 1131 ret = new TMssqlClose(vendor); 1132 break; 1133 } 1134 case sstmssqlbulkinsert: { 1135 ret = new TMssqlBulkInsert(vendor); 1136 break; 1137 } 1138 case sstmssqldeallocate: { 1139 ret = new TMssqlDeallocate(vendor); 1140 break; 1141 } 1142 case sstmssqlraiserror: { 1143 ret = new TMssqlRaiserror(vendor); 1144 break; 1145 } 1146 case sstmssqlgoto: { 1147 ret = new TMssqlGoTo(vendor); 1148 break; 1149 } 1150 case sstmssqldropview: { 1151 ret = new TDropViewSqlStatement(vendor); 1152 break; 1153 } 1154 case sstmssqldroptable: { 1155 ret = new TDropTableSqlStatement(vendor); 1156 break; 1157 } 1158 case sstmssqldropindex: { 1159 ret = new TDropIndexSqlStatement(vendor); 1160 break; 1161 } 1162 case sstmssqldroppartitionscheme: 1163 ret = new TDropPartitionSchemeStmt(vendor); 1164 break; 1165 case sstmssqldroppartitionfunction: 1166 ret = new gudusoft.gsqlparser.stmt.mssql.TDropPartitionFunctionStmt(vendor); 1167 break; 1168 case sstmssqldropaggregate: 1169 case sstmssqldropapplicationrole: 1170 case sstmssqldropassembly: 1171 case sstmssqldropasymmetrickey: 1172 case sstmssqldropcertificate: 1173 case sstmssqldropcontract: 1174 case sstmssqldropcredential: 1175 case sstmssqldropdefault: 1176 case sstmssqldropendpoint: 1177 case sstmssqldropeventnotification: 1178 case sstmssqldropfulltextcatalog: 1179 case sstmssqldropfulltextindex: 1180 case sstmssqldroplogin: 1181 case sstmssqldropmasterkey: 1182 case sstmssqldropmessagetype: 1183 case sstmssqldropqueue: 1184 case sstmssqldropremoteservicebinding: 1185 case sstmssqldroprole: 1186 case sstmssqldroproute: 1187 case sstmssqldroprule: 1188 case sstmssqldropservice: 1189 case sstmssqldropsignature: 1190 case sstmssqldropstatistics: 1191 case sstmssqldropsymmetrickey: 1192 case sstmssqldroptrigger: 1193 case sstmssqldroptype: 1194 case sstmssqldropuser: 1195 case sstmssqldropxmlschemacollection: 1196 case sstmssqldropeventsession: { 1197 ret = new TMssqlDropDbObject(EDbVendor.dbvmssql); 1198 ret.sqlstatementtype = gnewsqlstatementtype; 1199 break; 1200 } 1201 case sstmssqldropsynonym: { 1202 ret = new TDropSynonymStmt(vendor); 1203 break; 1204 } 1205 case sstmssqldropprocedure: { 1206 ret = new TDropProcedureStmt(EDbVendor.dbvmssql); 1207 break; 1208 } 1209 case sstmssqldropdatabase: { 1210 ret = new TDropDatabaseStmt(EDbVendor.dbvmssql); 1211 break; 1212 } 1213 case sstmssqldropschema: { 1214 ret = new TDropSchemaSqlStatement(EDbVendor.dbvmssql); 1215 break; 1216 } 1217 case sstmssqltruncatetable: { 1218 ret = new TTruncateStatement(vendor); 1219 break; 1220 } 1221 case sstmssqlbegintran: { 1222 ret = new TBeginTran(vendor); 1223 break; 1224 } 1225 case sstmssqlsavetran: { 1226 if (vendor == EDbVendor.dbvodbc) { 1227 } else if (vendor == EDbVendor.dbvmssql) { 1228 ret = new TMssqlSaveTran(vendor); 1229 } 1230 break; 1231 } 1232 case sstmssqlcommit: { 1233 ret = new TMssqlCommit(vendor); 1234 break; 1235 } 1236 case sstmssqlrollback: { 1237 ret = new TMssqlRollback(vendor); 1238 break; 1239 } 1240 case sstmssqlreadtext: { 1241 // TSqlCmdsMssql is shared by odbc/soql (setVendor called) whose 1242 // grammars still stub these statements -- typed classes only for 1243 // the real mssql dialect. 1244 if (vendor == EDbVendor.dbvmssql) { 1245 ret = new TMssqlReadText(vendor); 1246 } else { 1247 ret = new TMssqlDummyStmt(vendor); 1248 ret.sqlstatementtype = gnewsqlstatementtype; 1249 } 1250 break; 1251 } 1252 case sstmssqlwritetext: { 1253 if (vendor == EDbVendor.dbvmssql) { 1254 ret = new TMssqlWriteText(vendor); 1255 } else { 1256 // shared dialects (odbc/soql) keep the legacy unknown-statement 1257 // handling this type previously fell through to 1258 ret = new TUnknownSqlStatement(vendor); 1259 ret.sqlstatementtype = gnewsqlstatementtype; 1260 } 1261 break; 1262 } 1263 case sstmssqldbcc: 1264 case sstmssqlrestore: 1265 case sstmssqlbackup: { 1266 ret = new TMssqlDummyStmt(vendor); 1267 ret.sqlstatementtype = gnewsqlstatementtype; 1268 break; 1269 } 1270 case sstmssqlreceive: { 1271 lcisnewsql = true; 1272 if (state != EFindSqlStateType.stnormal) { 1273 if ((lcisnewsql) && (TBaseType.assigned(lccurrentsqlstatement))) { 1274 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect)) { 1275 lcisnewsql = false; 1276 } 1277 } 1278 } 1279 if (lcisnewsql) { 1280 ret = new TMssqlDummyStmt(vendor); 1281 ret.sqlstatementtype = gnewsqlstatementtype; 1282 } 1283 break; 1284 } 1285 case sstcreateindex: { 1286 ret = new TCreateIndexSqlStatement(vendor); 1287 break; 1288 } 1289 case sstmssqlwaitfor: { 1290 ret = new TMssqlWaitFor(vendor); 1291 break; 1292 } 1293 case sstmerge: { 1294 lcisnewsql = true; 1295 1296 if (state != EFindSqlStateType.stnormal) { 1297 if (lccurrentsqlstatement != null) { 1298 // merge union, merge join 1299 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect) { 1300 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1301 if (lcnextsolidtoken != null) { 1302 if ((lcnextsolidtoken.tokencode == TBaseType.rrw_union) || (lcnextsolidtoken.tokencode == TBaseType.rrw_join)) { 1303 lcisnewsql = false; 1304 } 1305 } 1306 } 1307 // ALTER TABLE ... MERGE RANGE (value) 1308 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) { 1309 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1310 if (lcnextsolidtoken != null) { 1311 if (lcnextsolidtoken.toString().equalsIgnoreCase("RANGE")) { 1312 lcisnewsql = false; 1313 } 1314 } 1315 } 1316 } 1317 if (lcisnewsql) { 1318 TSourceToken nextSt = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1319 if (nextSt != null) { 1320 if (nextSt.tokencode == TBaseType.rrw_join) { 1321 lcisnewsql = false; 1322 } 1323 } 1324 } 1325 } 1326 1327 if (lcisnewsql) { 1328 ret = new TMergeSqlStatement(vendor); 1329 ret.sqlstatementtype = gnewsqlstatementtype; 1330 } 1331 break; 1332 } 1333 case sstmssqlbegintry: 1334 case sstmssqlbegincatch: { 1335 ret = new TMssqlBlock(vendor); 1336 ret.sqlstatementtype = gnewsqlstatementtype; 1337 break; 1338 } 1339 case sstmssqlexec: { 1340 lcisnewsql = true; 1341 // prev tokentext can't be with 1342 if (state != EFindSqlStateType.stnormal) { 1343 if (TBaseType.assigned(lccurrentsqlstatement)) { 1344 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 1345 if (lccurrentsqlstatement.dummytag == 1) { 1346 lcisnewsql = false; 1347 lccurrentsqlstatement.dummytag = 0; // no select is permitted after it 1348 } 1349 1350 TSourceToken valuesToken = token.searchToken(TBaseType.rrw_values, -token.posinlist); 1351 if (valuesToken != null) { 1352 // If EXEC is after values in insert statement, then this EXEC is independent 1353 TSourceToken insertToken = lccurrentsqlstatement.sourcetokenlist.get(0); 1354 if (valuesToken.posinlist > insertToken.posinlist) { 1355 lcisnewsql = true; 1356 } 1357 } 1358 } 1359 1360 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgrant) { 1361 if (TBaseType.assigned(lcprevsolidtoken)) { 1362 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 1363 lcisnewsql = false; 1364 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1365 lcisnewsql = false; 1366 } 1367 } 1368 1369 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateprocedure) 1370 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) 1371 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatefunction) 1372 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) 1373 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) 1374 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterfunction) 1375 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatequeue)) { 1376 if (TBaseType.assigned(lcprevsolidtoken)) { 1377 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) 1378 lcisnewsql = false; 1379 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1380 lcisnewsql = false; 1381 } 1382 } 1383 } 1384 } 1385 if (lcisnewsql) { 1386 ret = new TMssqlExecute(vendor); 1387 } 1388 break; 1389 } 1390 case sstmssqlexecuteas: { 1391 lcisnewsql = true; 1392 // prev tokentext can't be with 1393 if (state != EFindSqlStateType.stnormal) { 1394 if (TBaseType.assigned(lccurrentsqlstatement)) { 1395 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateprocedure) 1396 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) 1397 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreatefunction) 1398 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterprocedure) 1399 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlaltertrigger) 1400 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterfunction)) { 1401 if (TBaseType.assigned(lcprevsolidtoken)) { 1402 if (lcprevsolidtoken.tokencode == TBaseType.rrw_with) 1403 lcisnewsql = false; 1404 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 1405 lcisnewsql = false; 1406 } 1407 } 1408 } 1409 } 1410 if (lcisnewsql) { 1411 ret = new TMssqlExecuteAs(vendor); 1412 ret.sqlstatementtype = gnewsqlstatementtype; 1413 } 1414 break; 1415 } 1416 case sstmssqlset: { 1417 lcisnewsql = true; 1418 if (state != EFindSqlStateType.stnormal) { 1419 if (TBaseType.assigned(lccurrentsqlstatement)) { 1420 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif) { 1421 TSourceToken lcPPToken = lcsourcetokenlist.searchToken(TBaseType.rrw_update, "", token, -10); 1422 if (TBaseType.assigned(lcPPToken)) { 1423 lcisnewsql = false; 1424 } 1425 } 1426 1427 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstalterdatabase) { 1428 TSourceToken lcPPToken = lcsourcetokenlist.searchToken(TBaseType.rrw_alter, "", token, -10); 1429 if (TBaseType.assigned(lcPPToken)) { 1430 lcisnewsql = false; 1431 } 1432 } 1433 1434 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 1435 if (lcprevsolidtoken != null) { 1436 if (lcprevsolidtoken.tokencode == TBaseType.rrw_update) { 1437 lcisnewsql = false; 1438 } 1439 } 1440 } 1441 1442 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstupdate) { 1443 if (lccurrentsqlstatement.dummytag == 1) { 1444 // update statement still find set clause yet, so this is set clause in update statement 1445 lccurrentsqlstatement.dummytag = 0; 1446 lcisnewsql = false; 1447 } 1448 } 1449 1450 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlcreateeventsession) { 1451 lcisnewsql = false; 1452 } 1453 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) { 1454 // Only treat SET as part of ALTER TABLE for SET NULL/SET DEFAULT/SET (...) 1455 // Other SET variants (e.g. SET ANSI_PADDING) should start a new statement 1456 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1457 if (TBaseType.assigned(lcnextsolidtoken)) { 1458 if ((TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "null") == 0) 1459 || (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "default") == 0) 1460 || (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "(") == 0)) { 1461 lcisnewsql = false; 1462 } 1463 } 1464 } 1465 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlalterindex) { 1466 // ALTER INDEX ... SET ( option = value, ... ) — SET is part of the ALTER INDEX 1467 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1468 if (TBaseType.assigned(lcnextsolidtoken)) { 1469 if (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "(") == 0) { 1470 lcisnewsql = false; 1471 } 1472 } 1473 } 1474 } 1475 // ALTER INDEX ... SET (...) : the previous statement may have already been 1476 // closed; look back for "ALTER INDEX" pattern 1477 if (lcisnewsql) { 1478 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1479 if (TBaseType.assigned(lcnextsolidtoken) 1480 && TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "(") == 0) { 1481 TSourceToken lcAlterToken = lcsourcetokenlist.searchToken(TBaseType.rrw_alter, "", token, -20); 1482 if (TBaseType.assigned(lcAlterToken)) { 1483 TSourceToken lcAfterAlter = lcsourcetokenlist.nextsolidtoken(lcAlterToken.posinlist, 1, false); 1484 if (TBaseType.assigned(lcAfterAlter) 1485 && TBaseType.mycomparetext(lcAfterAlter.getAstext(), "index") == 0) { 1486 lcisnewsql = false; 1487 } 1488 } 1489 } 1490 } 1491 1492 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 1493 if (TBaseType.assigned(lcnextsolidtoken)) { 1494 // set null, set default 1495 if ((TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "null") == 0) 1496 || (TBaseType.mycomparetext(lcnextsolidtoken.getAstext(), "default") == 0)) { 1497 lcisnewsql = false; 1498 } 1499 } 1500 } 1501 1502 if (lcisnewsql) { 1503 ret = new TMssqlSet(vendor); 1504 } 1505 break; 1506 } 1507 case sstmssqlsetrowcount: { 1508 ret = new TMssqlSetRowCount(vendor); 1509 break; 1510 } 1511 case sstmssqlupdatetext: { 1512 ret = new TMssqlUpdateText(vendor); 1513 break; 1514 } 1515 case sstmssqlendconversation: { 1516 ret = new TMssqlEndConversation(vendor); 1517 break; 1518 } 1519 case sstmssqlbegindialog: { 1520 ret = new TMssqlBeginDialog(vendor); 1521 break; 1522 } 1523 case sstmssqlsendonconversation: { 1524 ret = new TMssqlSendOnConversation(vendor); 1525 break; 1526 } 1527 case sstdropsequence: 1528 ret = new TDropSequenceStmt(vendor); 1529 break; 1530 case sstaltersequence: 1531 ret = new gudusoft.gsqlparser.stmt.TAlterSequenceStatement(vendor); 1532 break; 1533 case sstmssqldisabletrigger: 1534 case sstmssqlenabletrigger: { 1535 lcisnewsql = true; 1536 if (TBaseType.assigned(lccurrentsqlstatement)) { 1537 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) 1538 lcisnewsql = false; 1539 } 1540 1541 if (lcisnewsql) { 1542 ret = new TUnknownSqlStatement(vendor); 1543 ret.sqlstatementtype = gnewsqlstatementtype; 1544 } 1545 break; 1546 } 1547 case sstmssqlthrow: 1548 ret = new TMssqlThrow(vendor); 1549 break; 1550 case sstmssqlalterdatabase: 1551 ret = new TAlterDatabaseStmt(vendor); 1552 break; 1553 case sstmssqlreconfigure: 1554 ret = new TReconfigure(vendor); 1555 break; 1556 case sstcreatedatabase: { 1557 ret = new TCreateDatabaseSqlStatement(vendor); 1558 break; 1559 } 1560 case sstmssqlcreatedatabaseencryptionkey: { 1561 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1562 stub.sqlstatementtype = ESqlStatementType.sstmssqlcreatedatabaseencryptionkey; 1563 ret = stub; 1564 break; 1565 } 1566 case sstmssqlcreateselectivexmlindex: { 1567 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1568 stub.sqlstatementtype = ESqlStatementType.sstmssqlcreateselectivexmlindex; 1569 ret = stub; 1570 break; 1571 } 1572 case sstmssqlcreatejsonindex: { 1573 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1574 stub.sqlstatementtype = ESqlStatementType.sstmssqlcreatejsonindex; 1575 ret = stub; 1576 break; 1577 } 1578 case sstmssqlcreatevectorindex: { 1579 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1580 stub.sqlstatementtype = ESqlStatementType.sstmssqlcreatevectorindex; 1581 ret = stub; 1582 break; 1583 } 1584 case sstmssqlrenameobject: { 1585 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1586 stub.sqlstatementtype = ESqlStatementType.sstmssqlrenameobject; 1587 ret = stub; 1588 break; 1589 } 1590 case sstmssqlcreateremotetableasselect: { 1591 TMssqlStmtStub stub = new TMssqlStmtStub(vendor); 1592 stub.sqlstatementtype = ESqlStatementType.sstmssqlcreateremotetableasselect; 1593 ret = stub; 1594 break; 1595 } 1596 case sstmssqlcreateschema: { 1597 ret = new TCreateSchemaSqlStatement(vendor); 1598 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) { 1599 lctoken = lcsourcetokenlist.get(k); 1600 if (lctoken.isnonsolidtoken()) continue; 1601 if (lctoken.tokencode == TBaseType.rrw_go) break; 1602 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 1603 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 1604 } 1605 break; 1606 } 1607 case sstmssqlcreatesynonym: { 1608 ret = new TCreateSynonymStmt(vendor); 1609 break; 1610 } 1611 case sstmssqlcreatetype: 1612 ret = new TMssqlCreateType(vendor); 1613 break; 1614 case sstmssqlcreatexmlschemacollection: 1615 ret = new TMssqlCreateXmlSchemaCollectionStmt(vendor); 1616 break; 1617 case sstmssqlalterindex: 1618 if (TBaseType.assigned(lccurrentsqlstatement) 1619 && lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltertable) { 1620 ret = null; 1621 } else { 1622 ret = new TAlterIndexStmt(vendor); 1623 } 1624 break; 1625 case sstmssqlcreateevexternalDataSource: 1626 ret = new TCreateExternalDataSourceStmt(vendor); 1627 break; 1628 case sstmssqlcreateeventsession: 1629 ret = new TCreateEventSession(vendor); 1630 break; 1631 case sstmssqldropfunction: 1632 ret = new TDropFunctionStmt(vendor); 1633 break; 1634 case sstmssqlcreateevexternalLanguage: 1635 ret = new TCreateExternalLanguage(vendor); 1636 break; 1637 case sstmssqlalterview: { 1638 lcisnewsql = true; 1639 if (TBaseType.assigned(lccurrentsqlstatement)) { 1640 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 1641 lcisnewsql = false; 1642 } 1643 1644 if (lcisnewsql) { 1645 ret = new TAlterViewStatement(vendor); 1646 } 1647 break; 1648 } 1649 case sstCreateFileFormat: { 1650 ret = new TCreateFileFormatStmt(vendor); 1651 break; 1652 } 1653 case sstmssqlcreatemasterkey: 1654 ret = new TCreateMasterKeyStmt(vendor); 1655 break; 1656 case sstcreatecredential: 1657 ret = new TCreateCredentialStmt(vendor); 1658 break; 1659 case sstCopyInto: { 1660 ret = new TMssqlCopyIntoStmt(vendor); 1661 break; 1662 } 1663 case sstcreatematerializedview: { 1664 ret = new TCreateMaterializedSqlStatement(vendor); 1665 break; 1666 } 1667 case sstmssqlCreateSecurityPolicy: 1668 ret = new TMssqlCreateSecurityPolicy(vendor); 1669 break; 1670 case sstmssqlAlterSecurityPolicy: 1671 ret = new TMssqlAlterSecurityPolicy(vendor); 1672 break; 1673 case sstmssqlDropSecurityPolicy: 1674 ret = new TMssqlDropSecurityPolicy(vendor); 1675 break; 1676 case sstmssqlalterpartitionfunction: 1677 ret = new TAlterPartitionFunctionStmt(vendor); 1678 break; 1679 case sstmssqlcreatepartitionfunction: 1680 ret = new TCreatePartitionFunctionStmt(vendor); 1681 break; 1682 case sstmssqlalterpartitionscheme: 1683 ret = new TAlterPartitionSchemeSqlStatement(vendor); 1684 break; 1685 case sstmssqlcreatepartitionscheme: 1686 ret = new TCreatePartitionSchemeSqlStatement(vendor); 1687 break; 1688 case sstmssqlupdatestatistics: 1689 ret = new TMssqlUpdateStatistics(vendor); 1690 break; 1691 default: { 1692 ret = new TUnknownSqlStatement(vendor); 1693 ret.sqlstatementtype = gnewsqlstatementtype; 1694 break; 1695 } 1696 } 1697 return ret; 1698 } 1699 1700 /** 1701 * Whether this right parenthesis closes the body of a WITH-clause item — 1702 * a CTE ({@code WITH cte AS (...)}, possibly with a column list and 1703 * possibly chained with commas) or {@code WITH XMLNAMESPACES (...)}. A 1704 * SELECT right after such a ')' is the view body's continuation (the CTE 1705 * anchor query). A ')' that closes anything else — a table hint 1706 * {@code WITH (NOLOCK)}, a named window {@code WINDOW w AS (ORDER BY a)}, 1707 * a derived table, a function call — ends a complete view body, and a 1708 * SELECT after it starts a new statement. (Mantis #4678) 1709 */ 1710 private static boolean closesWithClauseItem(TSourceToken rparen) { 1711 TSourceToken lp = matchingLeftParen(rparen); 1712 if (lp == null) return false; 1713 TSourceToken t = lp.prevSolidToken(); 1714 // Walk the "name AS ( ... ) [, name AS ( ... )]*" chain leftward until 1715 // the token that introduces it. WITH => CTE / XMLNAMESPACES list 1716 // (continue the view body); anything else (WINDOW, an alias, ...) is 1717 // not a view-body prefix (split). Every step moves strictly left in 1718 // the token list, so the walk always terminates. 1719 while (t != null) { 1720 if ("XMLNAMESPACES".equalsIgnoreCase(t.toString())) { // keyword text, not an identifier 1721 TSourceToken w = t.prevSolidToken(); 1722 return (w != null) && (w.tokencode == TBaseType.rrw_with); 1723 } 1724 if (t.tokencode != TBaseType.rrw_as) return false; 1725 TSourceToken name = t.prevSolidToken(); // CTE name, or ')' of its column list 1726 if (name != null && name.tokentype == ETokenType.ttrightparenthesis) { 1727 TSourceToken cl = matchingLeftParen(name); 1728 if (cl == null) return false; 1729 name = cl.prevSolidToken(); 1730 } 1731 if (name == null) return false; 1732 TSourceToken intro = name.prevSolidToken(); 1733 if (intro == null) return false; 1734 if (intro.tokencode == TBaseType.rrw_with) return true; 1735 if (intro.tokentype != ETokenType.ttcomma) return false; 1736 // preceding chain item: "... ( ... ) , name AS" — step into it 1737 TSourceToken prevBody = intro.prevSolidToken(); 1738 if (prevBody == null || prevBody.tokentype != ETokenType.ttrightparenthesis) return false; 1739 TSourceToken prevLp = matchingLeftParen(prevBody); 1740 if (prevLp == null) return false; 1741 t = prevLp.prevSolidToken(); 1742 } 1743 return false; 1744 } 1745 1746 /** The '(' matching this ')' in the same token list, or null. */ 1747 private static TSourceToken matchingLeftParen(TSourceToken rparen) { 1748 TSourceTokenList list = rparen.container; 1749 if (list == null) return null; 1750 int depth = 0; 1751 for (int i = rparen.posinlist; i >= 0; i--) { 1752 TSourceToken t = list.get(i); 1753 if (t.tokentype == ETokenType.ttrightparenthesis) { 1754 depth++; 1755 } else if (t.tokentype == ETokenType.ttleftparenthesis) { 1756 depth--; 1757 if (depth == 0) return t; 1758 } 1759 } 1760 return null; 1761 } 1762 1763}