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