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