001package gudusoft.gsqlparser.sqlcmds; 002 003import gudusoft.gsqlparser.*; 004import gudusoft.gsqlparser.stmt.*; 005import gudusoft.gsqlparser.stmt.hana.*; 006 007/** 008 * SAP HANA SQL command resolver. 009 * Contains all HANA-specific SQL command recognition logic. 010 * 011 * @since 3.1.0.9 012 */ 013public class TSqlCmdsHana extends AbstractSqlCmds { 014 015 // Temporary field for statement type during issql processing 016 private ESqlStatementType gnewsqlstatementtype = ESqlStatementType.sstinvalid; 017 018 public TSqlCmdsHana() { 019 super(EDbVendor.dbvhana); 020 } 021 022 @Override 023 protected String getToken1Str(int token1) { 024 // HANA vendor-specific reserved words requiring token1Str mapping 025 switch (token1) { 026 case TBaseType.rrw_hana_unset: 027 return "unset"; 028 case TBaseType.rrw_hana_upsert: 029 return "upsert"; 030 case TBaseType.rrw_hana_import: 031 return "import"; 032 case TBaseType.rrw_hana_export: 033 return "export"; 034 case TBaseType.rrw_hana_recover: 035 return "recover"; 036 case TBaseType.rrw_hana_unload: 037 return "unload"; 038 case TBaseType.rrw_hana_validate: 039 return "validate"; 040 default: 041 return null; 042 } 043 } 044 045 @Override 046 protected void initializeCommands() { 047 // ALTER commands 048 addCmd(TBaseType.rrw_alter, "audit", "policy", ESqlStatementType.sstalterauditpolicy); 049 addCmd(TBaseType.rrw_alter, "credential", ESqlStatementType.sstaltercredential); 050 addCmd(TBaseType.rrw_alter, "database", ESqlStatementType.sstalterdatabase); 051 addCmd(TBaseType.rrw_alter, "fulltext", "index", ESqlStatementType.sstalterfulltextindex); 052 addCmd(TBaseType.rrw_alter, "function", ESqlStatementType.sstalterfunction); 053 addCmd(TBaseType.rrw_alter, "index", ESqlStatementType.sstalterindex); 054 addCmd(TBaseType.rrw_alter, "ldap", "provider", ESqlStatementType.sstalterldapprovider); 055 addCmd(TBaseType.rrw_alter, "jwt", "provider", ESqlStatementType.sstalterjwtprovider); 056 addCmd(TBaseType.rrw_alter, "pse", ESqlStatementType.sstalterpse); 057 addCmd(TBaseType.rrw_alter, "procedure", ESqlStatementType.sstalterprocedure); 058 addCmd(TBaseType.rrw_alter, "remote", "source", ESqlStatementType.sstalterremotesource); 059 addCmd(TBaseType.rrw_alter, "role", ESqlStatementType.sstAlterRole); 060 addCmd(TBaseType.rrw_alter, "saml", "provider", ESqlStatementType.sstaltersamlprovider); 061 addCmd(TBaseType.rrw_alter, "sequence", ESqlStatementType.sstaltersequence); 062 addCmd(TBaseType.rrw_alter, "statistics", ESqlStatementType.sstalterstatistics); 063 addCmd(TBaseType.rrw_alter, "structured", "privilege", ESqlStatementType.sstalterstructuredprivilege); 064 addCmd(TBaseType.rrw_alter, "system", ESqlStatementType.sstaltersystem); 065 addCmd(TBaseType.rrw_alter, "table", ESqlStatementType.sstaltertable); 066 addCmd(TBaseType.rrw_alter, "user", ESqlStatementType.sstalteruser); 067 addCmd(TBaseType.rrw_alter, "usergroup", ESqlStatementType.sstalterusergroup); 068 addCmd(TBaseType.rrw_alter, "view", "cache", ESqlStatementType.sstalterviewcache); 069 addCmd(TBaseType.rrw_alter, "view", ESqlStatementType.sstalterview); 070 addCmd(TBaseType.rrw_alter, "virtual", "table", ESqlStatementType.sstaltervirtualtable); 071 addCmd(TBaseType.rrw_alter, "workload", "class", ESqlStatementType.sstalterworkloadclass); 072 addCmd(TBaseType.rrw_alter, "workload", "mapping", ESqlStatementType.sstalterworkloadmapping); 073 074 // BACKUP commands 075 addCmd(TBaseType.rrw_backup, "cancel", ESqlStatementType.sstbackupcancel); 076 addCmd(TBaseType.rrw_backup, "catalog", "delete", ESqlStatementType.sstbackupcatalogdelete); 077 addCmd(TBaseType.rrw_backup, "check", "access", ESqlStatementType.sstbackupcheckaccess); 078 addCmd(TBaseType.rrw_backup, "check", ESqlStatementType.sstbackupcheck); 079 addCmd(TBaseType.rrw_backup, "data", ESqlStatementType.sstbackupdata); 080 addCmd(TBaseType.rrw_backup, "list", "data", ESqlStatementType.sstbackuplistdata); 081 082 // CALL command 083 addCmd(TBaseType.rrw_call, ESqlStatementType.sstcall); 084 085 // COMMENT/COMMIT/CONNECT commands 086 addCmd(TBaseType.rrw_comment, "on", ESqlStatementType.sstcomment); 087 addCmd(TBaseType.rrw_commit, ESqlStatementType.sstcommit); 088 addCmd(TBaseType.rrw_connect, ESqlStatementType.sstconnect); 089 090 // CREATE commands - ordered with longer patterns first 091 addCmd(TBaseType.rrw_create, "audit", "policy", ESqlStatementType.sstcreateauditpolicy); 092 addCmd(TBaseType.rrw_create, "btree", "index", ESqlStatementType.sstcreateindex); 093 addCmd(TBaseType.rrw_create, "certificate", ESqlStatementType.sstcreatecertificate); 094 addCmd(TBaseType.rrw_create, "collection", ESqlStatementType.sstcreatecollection); 095 addCmd(TBaseType.rrw_create, "column", "table", ESqlStatementType.sstcreatetable); 096 addCmd(TBaseType.rrw_create, "cpbtree", "index", ESqlStatementType.sstcreateindex); 097 addCmd(TBaseType.rrw_create, "credential", ESqlStatementType.sstcreatecredential); 098 addCmd(TBaseType.rrw_create, "database", ESqlStatementType.sstcreatedatabase); 099 addCmd(TBaseType.rrw_create, "fulltext", "index", ESqlStatementType.sstcreatefulltextindex); 100 addCmd(TBaseType.rrw_create, "function", ESqlStatementType.sstcreatefunction); 101 addCmd(TBaseType.rrw_create, "global", "temporary", "column", "table", ESqlStatementType.sstcreatetable); 102 addCmd(TBaseType.rrw_create, "global", "temporary", "table", ESqlStatementType.sstcreatetable); 103 addCmd(TBaseType.rrw_create, "graph", "workspace", ESqlStatementType.sstcreategraphworkspace); 104 addCmd(TBaseType.rrw_create, "history", "column", "table", ESqlStatementType.sstcreatetable); 105 addCmd(TBaseType.rrw_create, "index", ESqlStatementType.sstcreateindex); 106 addCmd(TBaseType.rrw_create, "jwt", "provider", ESqlStatementType.sstcreateJWTProvider); 107 addCmd(TBaseType.rrw_create, "ldap", "provider", ESqlStatementType.sstcreateLDAPProvider); 108 addCmd(TBaseType.rrw_create, "local", "temporary", "column", "table", ESqlStatementType.sstcreatetable); 109 addCmd(TBaseType.rrw_create, "local", "temporary", "table", ESqlStatementType.sstcreatetable); 110 addCmd(TBaseType.rrw_create, "or", "replace", "force", "editionable", "view", ESqlStatementType.sstcreateview); 111 addCmd(TBaseType.rrw_create, "or", "replace", "public", "synonym", ESqlStatementType.sstcreatesynonym); 112 addCmd(TBaseType.rrw_create, "or", "replace", "synonym", ESqlStatementType.sstcreatesynonym); 113 addCmd(TBaseType.rrw_create, "or", "replace", "view", ESqlStatementType.sstcreateview); 114 addCmd(TBaseType.rrw_create, "procedure", ESqlStatementType.sstcreateprocedure); 115 addCmd(TBaseType.rrw_create, "pse", ESqlStatementType.sstcreatepse); 116 addCmd(TBaseType.rrw_create, "public", "synonym", ESqlStatementType.sstcreatesynonym); 117 addCmd(TBaseType.rrw_create, "remote", "source", ESqlStatementType.sstcreateremotesource); 118 addCmd(TBaseType.rrw_create, "restricted", "user", ESqlStatementType.sstcreateuser); 119 addCmd(TBaseType.rrw_create, "role", ESqlStatementType.sstcreaterole); 120 addCmd(TBaseType.rrw_create, "row", "table", ESqlStatementType.sstcreatetable); 121 addCmd(TBaseType.rrw_create, "saml", "provider", ESqlStatementType.sstcreatesamlprovider); 122 addCmd(TBaseType.rrw_create, "schema", ESqlStatementType.sstcreateschema); 123 addCmd(TBaseType.rrw_create, "sequence", ESqlStatementType.sstcreatesequence); 124 addCmd(TBaseType.rrw_create, "statistics", ESqlStatementType.sstcreatestatistics); 125 addCmd(TBaseType.rrw_create, "structured", "privilege", ESqlStatementType.sstcreatestructuredprivilege); 126 addCmd(TBaseType.rrw_create, "synonym", ESqlStatementType.sstcreatesynonym); 127 addCmd(TBaseType.rrw_create, "table", ESqlStatementType.sstcreatetable); 128 addCmd(TBaseType.rrw_create, "trigger", ESqlStatementType.sstcreatetrigger); 129 addCmd(TBaseType.rrw_create, "type", ESqlStatementType.sstcreatetype); 130 addCmd(TBaseType.rrw_create, "unique", "index", ESqlStatementType.sstcreateindex); 131 addCmd(TBaseType.rrw_create, "user", ESqlStatementType.sstcreateuser); 132 addCmd(TBaseType.rrw_create, "usergroup", ESqlStatementType.sstcreateusergroup); 133 addCmd(TBaseType.rrw_create, "view", ESqlStatementType.sstcreateview); 134 addCmd(TBaseType.rrw_create, "virtual", "function", ESqlStatementType.sstcreatevirtualfunction); 135 addCmd(TBaseType.rrw_create, "virtual", "table", ESqlStatementType.sstcreatevirtualtable); 136 addCmd(TBaseType.rrw_create, "workload", "class", ESqlStatementType.sstcreateworkloadclass); 137 addCmd(TBaseType.rrw_create, "workload", "mapping", ESqlStatementType.sstcreateworkloadmapping); 138 139 // DELETE command 140 addCmd(TBaseType.rrw_delete, ESqlStatementType.sstdelete); 141 142 // DO command 143 addCmd(TBaseType.rrw_do, "begin", ESqlStatementType.sstdobeginend); 144 145 // DROP commands - ordered with longer patterns first 146 addCmd(TBaseType.rrw_drop, "audit", "policy", ESqlStatementType.sstdropauditpolicy); 147 addCmd(TBaseType.rrw_drop, "certificate", ESqlStatementType.sstdropcertificate); 148 addCmd(TBaseType.rrw_drop, "collection", ESqlStatementType.sstdropcollection); 149 addCmd(TBaseType.rrw_drop, "credential", ESqlStatementType.sstdropcredential); 150 addCmd(TBaseType.rrw_drop, "database", ESqlStatementType.sstdropdatabase); 151 addCmd(TBaseType.rrw_drop, "fulltext", "index", ESqlStatementType.sstdropfulltextindex); 152 addCmd(TBaseType.rrw_drop, "function", ESqlStatementType.sstdropfunction); 153 addCmd(TBaseType.rrw_drop, "graph", "workspace", ESqlStatementType.sstdropgraphworkspace); 154 addCmd(TBaseType.rrw_drop, "index", ESqlStatementType.sstdropindex); 155 addCmd(TBaseType.rrw_drop, "jwt", "provider", ESqlStatementType.sstdropJWTProvider); 156 addCmd(TBaseType.rrw_drop, "ldap", "provider", ESqlStatementType.sstdropLDAPProvider); 157 addCmd(TBaseType.rrw_drop, "procedure", ESqlStatementType.sstdropprocedure); 158 addCmd(TBaseType.rrw_drop, "pse", ESqlStatementType.sstdroppse); 159 addCmd(TBaseType.rrw_drop, "public", "synonym", ESqlStatementType.sstdropsynonym); 160 addCmd(TBaseType.rrw_drop, "remote", "source", ESqlStatementType.sstdropremotesource); 161 addCmd(TBaseType.rrw_drop, "role", ESqlStatementType.sstdroprole); 162 addCmd(TBaseType.rrw_drop, "saml", "provider", ESqlStatementType.sstdropsamlprovider); 163 addCmd(TBaseType.rrw_drop, "schema", ESqlStatementType.sstdropschema); 164 addCmd(TBaseType.rrw_drop, "sequence", ESqlStatementType.sstdropsequence); 165 addCmd(TBaseType.rrw_drop, "statistics", ESqlStatementType.sstdropstatistics); 166 addCmd(TBaseType.rrw_drop, "structured", "privilege", ESqlStatementType.sstdropstructuredprivilege); 167 addCmd(TBaseType.rrw_drop, "synonym", ESqlStatementType.sstdropsynonym); 168 addCmd(TBaseType.rrw_drop, "table", ESqlStatementType.sstdroptable); 169 addCmd(TBaseType.rrw_drop, "trigger", ESqlStatementType.sstdroptrigger); 170 addCmd(TBaseType.rrw_drop, "type", ESqlStatementType.sstdroptype); 171 addCmd(TBaseType.rrw_drop, "user", ESqlStatementType.sstdropuser); 172 addCmd(TBaseType.rrw_drop, "usergroup", ESqlStatementType.sstdropusergroup); 173 addCmd(TBaseType.rrw_drop, "view", ESqlStatementType.sstdropview); 174 addCmd(TBaseType.rrw_drop, "workload", "class", ESqlStatementType.sstdropworkloadclass); 175 addCmd(TBaseType.rrw_drop, "workload", "mapping", ESqlStatementType.sstdropworkloadmapping); 176 177 // EXPLAIN/EXPORT commands 178 addCmd(TBaseType.rrw_explain, "plan", ESqlStatementType.sstExplain); 179 addCmd(TBaseType.rrw_hana_export, ESqlStatementType.sstexport); 180 181 // GRANT command 182 addCmd(TBaseType.rrw_grant, ESqlStatementType.sstGrant); 183 184 // IMPORT commands 185 addCmd(TBaseType.rrw_hana_import, "from", ESqlStatementType.sstimportfrom); 186 addCmd(TBaseType.rrw_hana_import, "scan", ESqlStatementType.sstimportscan); 187 addCmd(TBaseType.rrw_hana_import, ESqlStatementType.sstimport); 188 189 // INSERT command 190 addCmd(TBaseType.rrw_insert, ESqlStatementType.sstinsert); 191 192 // LOAD/LOCK commands 193 addCmd(TBaseType.rrw_load, ESqlStatementType.sstload); 194 addCmd(TBaseType.rrw_lock, "table", ESqlStatementType.sstlocktable); 195 196 // MERGE commands 197 addCmd(TBaseType.rrw_merge, "history", "delta", ESqlStatementType.sstmergedelta); 198 addCmd(TBaseType.rrw_merge, "delta", ESqlStatementType.sstmergedelta); 199 addCmd(TBaseType.rrw_merge, "into", ESqlStatementType.sstmerge); 200 201 // RECOVER commands 202 addCmd(TBaseType.rrw_hana_recover, "database", ESqlStatementType.sstrecoverdatabase); 203 addCmd(TBaseType.rrw_hana_recover, "data", ESqlStatementType.sstrecoverdata); 204 205 // REFRESH/RENAME commands 206 addCmd(TBaseType.rrw_refresh, "statistics", ESqlStatementType.sstrefreshstatistics); 207 addCmd(TBaseType.rrw_rename, "collection", ESqlStatementType.sstrenamecollection); 208 addCmd(TBaseType.rrw_rename, "column", ESqlStatementType.sstrenamecolumn); 209 addCmd(TBaseType.rrw_rename, "database", ESqlStatementType.sstrenamedatabase); 210 addCmd(TBaseType.rrw_rename, "index", ESqlStatementType.sstrenameindex); 211 addCmd(TBaseType.rrw_rename, "table", ESqlStatementType.sstrenametable); 212 213 // REPLACE command 214 addCmd(TBaseType.rrw_replace, ESqlStatementType.sstreplace); 215 216 // REVOKE/ROLLBACK commands 217 addCmd(TBaseType.rrw_revoke, ESqlStatementType.sstRevoke); 218 addCmd(TBaseType.rrw_rollback, ESqlStatementType.sstrollback); 219 220 // SAVEPOINT command 221 addCmd(TBaseType.rrw_savepoint, ESqlStatementType.sstsavepoint); 222 223 // SELECT command 224 addCmd(TBaseType.rrw_select, ESqlStatementType.sstselect); 225 226 // SET commands - ordered with longer patterns first 227 addCmd(TBaseType.rrw_set, "history", "session", ESqlStatementType.sssethistorysession); 228 addCmd(TBaseType.rrw_set, "pse", ESqlStatementType.sstsetpse); 229 addCmd(TBaseType.rrw_set, "schema", ESqlStatementType.sstsetschema); 230 addCmd(TBaseType.rrw_set, "system", "license", ESqlStatementType.sstsetsystemlicense); 231 addCmd(TBaseType.rrw_set, "transaction", "autocommit", ESqlStatementType.sstsettransactionautocommit); 232 addCmd(TBaseType.rrw_set, "transaction", ESqlStatementType.sstsettransaction); 233 addCmd(TBaseType.rrw_set, ESqlStatementType.sstset); 234 235 // START TRANSACTION command 236 addCmd(TBaseType.rrw_start, "transaction", ESqlStatementType.sstStartTransaction); 237 238 // TRUNCATE commands 239 addCmd(TBaseType.rrw_truncate, "collection", ESqlStatementType.ssttruncatecollection); 240 addCmd(TBaseType.rrw_truncate, "table", ESqlStatementType.ssttruncatetable); 241 242 // UNLOAD/UNSET commands 243 addCmd(TBaseType.rrw_hana_unload, ESqlStatementType.sstunload); 244 addCmd(TBaseType.rrw_hana_unset, "pse", ESqlStatementType.sstunsetpse); 245 addCmd(TBaseType.rrw_hana_unset, "system", "license", ESqlStatementType.sstunsetsystemlicense); 246 addCmd(TBaseType.rrw_hana_unset, ESqlStatementType.sstunset); 247 248 // UPDATE command 249 addCmd(TBaseType.rrw_update, ESqlStatementType.sstupdate); 250 251 // UPSERT/VALIDATE commands 252 addCmd(TBaseType.rrw_hana_upsert, ESqlStatementType.sstupsert); 253 addCmd(TBaseType.rrw_hana_validate, "ldap", "provider", ESqlStatementType.sstvalidateLDAPProvider); 254 addCmd(TBaseType.rrw_hana_validate, "user", ESqlStatementType.sstvalidateUser); 255 } 256 257 @Override 258 public TCustomSqlStatement issql(TSourceToken pcst, EFindSqlStateType pstate, TCustomSqlStatement psqlstatement) { 259 TCustomSqlStatement ret = null; 260 int k; 261 boolean lcisnewsql; 262 TSourceToken lcpprevsolidtoken, lcnextsolidtoken, lctoken; 263 264 gnewsqlstatementtype = ESqlStatementType.sstinvalid; 265 266 if ((pcst.tokencode == TBaseType.cmtdoublehyphen) 267 || (pcst.tokencode == TBaseType.cmtslashstar) 268 || (pcst.tokencode == TBaseType.lexspace) 269 || (pcst.tokencode == TBaseType.lexnewline) 270 || (pcst.tokentype == ETokenType.ttsemicolon)) { 271 return ret; 272 } 273 274 int lcpos = pcst.posinlist; 275 TSourceTokenList lcsourcetokenlist = pcst.container; 276 TCustomSqlStatement lccurrentsqlstatement = psqlstatement; 277 278 // Subquery after semicolon || at first line 279 if (pcst.tokentype == ETokenType.ttleftparenthesis) { // ( 280 k = lcsourcetokenlist.solidtokenafterpos(lcpos, TBaseType.rrw_select, 1, "("); 281 if (k > 0) { 282 if (pstate == EFindSqlStateType.stnormal) { 283 ret = new TSelectSqlStatement(this.vendor); 284 return ret; 285 } 286 } 287 } 288 289 // CTE 290 if ((pstate == EFindSqlStateType.stnormal) && (pcst.tokencode == TBaseType.rrw_with)) { 291 ret = findcte(pcst); 292 if ((ret != null)) return ret; 293 } 294 295 gnewsqlstatementtype = getStatementTypeForToken(pcst); 296 297 TSourceToken lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 298 switch (gnewsqlstatementtype) { 299 case sstinvalid: { 300 // HANA doesn't support MSSQL-style labels 301 ret = null; 302 break; 303 } 304 case sstselect: { 305 lcisnewsql = true; 306 307 if (pstate != EFindSqlStateType.stnormal) { 308 if ((lcprevsolidtoken != null)) { 309 if (lcprevsolidtoken.tokentype == ETokenType.ttleftparenthesis) 310 lcisnewsql = false; // subquery 311 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_union) 312 lcisnewsql = false; 313 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_intersect) 314 lcisnewsql = false; 315 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_minus) 316 lcisnewsql = false; 317 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_except) 318 lcisnewsql = false; 319 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_return) 320 lcisnewsql = false; 321 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_as) { 322 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 323 lcisnewsql = false; 324 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 325 lcisnewsql = false; 326 } else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) { 327 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlset) 328 lcisnewsql = false; 329 } else if (lcprevsolidtoken.tokentype == ETokenType.ttrightparenthesis) { 330 if ((lccurrentsqlstatement != null) && (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable)) { 331 lcisnewsql = false; 332 } 333 } 334 335 if (lcisnewsql && (lcprevsolidtoken.tokencode == TBaseType.rrw_all)) { 336 lcpprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcprevsolidtoken.posinlist); 337 if ((lcpprevsolidtoken != null)) { 338 if (lcpprevsolidtoken.tokencode == TBaseType.rrw_union) 339 lcisnewsql = false; 340 } 341 } 342 343 } 344 345 if ((lccurrentsqlstatement != null)) { 346 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 347 lcisnewsql = false; 348 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstGrant) { 349 if ((lcprevsolidtoken != null)) { 350 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 351 lcisnewsql = false; 352 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 353 lcisnewsql = false; 354 } 355 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) { 356 lcisnewsql = false; 357 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstaltersequence) { 358 lcisnewsql = false; 359 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstExplain) { 360 lcisnewsql = false; 361 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstRevoke) { 362 lcisnewsql = false; 363 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstupsert) { 364 lcisnewsql = false; 365 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstalterview) { 366 lcisnewsql = false; 367 } 368 } 369 370 } 371 372 if (lcisnewsql) 373 ret = new TSelectSqlStatement(this.vendor); 374 375 break; 376 377 } 378 case sstinsert: { 379 lcisnewsql = true; 380 if (pstate != EFindSqlStateType.stnormal) { 381 if ((lccurrentsqlstatement != null)) { 382 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateauditpolicy) { 383 lcisnewsql = false; 384 } 385 // merge 386 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 387 if (lcprevsolidtoken != null) { 388 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 389 lcisnewsql = false; 390 } 391 } 392 } 393 394 395 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstGrant) { 396 if ((lcprevsolidtoken != null)) { 397 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 398 lcisnewsql = false; 399 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 400 lcisnewsql = false; 401 } 402 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstRevoke) { 403 // Fix for issue #4315: REVOKE INSERT should not split into two statements 404 if ((lcprevsolidtoken != null)) { 405 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 406 lcisnewsql = false; 407 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 408 lcisnewsql = false; 409 } 410 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 411 lcisnewsql = false; 412 } 413 414 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 415 if ((lcprevsolidtoken != null)) { 416 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 417 lcisnewsql = false; 418 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 419 lcisnewsql = false; 420 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 421 lcisnewsql = false; 422 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 423 lcisnewsql = false; 424 } 425 } 426 427 428 } 429 } 430 431 if (lcisnewsql) { 432 ret = new TInsertSqlStatement(this.vendor); 433 ret.dummytag = 1; // select stmt in insert is permitted 434 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) // iterate 435 { 436 if (lcsourcetokenlist.get(k).isnonsolidtoken()) continue; 437 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_values) break; 438 if (lcsourcetokenlist.get(k).tokentype == ETokenType.ttsemicolon) break; 439 if (lcsourcetokenlist.get(k).tokencode == TBaseType.rrw_select) { 440 ret.dummytag = 0; 441 break; 442 } 443 } // for ( 444 if (k > lcsourcetokenlist.size() - 1) 445 k = lcsourcetokenlist.size() - 1; 446 447 for (int i = lcpos + 1; i <= k; i++) // iterate 448 { 449 lcsourcetokenlist.get(i).tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 450 } // for ( 451 452 } 453 454 break; 455 } 456 case sstupdate: { 457 lcisnewsql = true; 458 if (pstate != EFindSqlStateType.stnormal) { 459 if ((lcprevsolidtoken != null)) { // 460 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 461 lcisnewsql = false; 462 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 463 lcisnewsql = false; 464 } 465 466 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 467 if (TBaseType.assigned(lcnextsolidtoken)) { 468 if (lcnextsolidtoken.tokentype == ETokenType.ttleftparenthesis) { 469 k = lcsourcetokenlist.solidtokenafterpos(lcnextsolidtoken.posinlist, TBaseType.rrw_select, 1, "("); 470 if (k == 0) lcisnewsql = false; 471 } 472 } 473 474 475 if (TBaseType.assigned(lccurrentsqlstatement)) { 476 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateauditpolicy) { 477 lcisnewsql = false; 478 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 479 lcisnewsql = false; 480 } 481 // merge 482 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge) { 483 if (lcprevsolidtoken != null) { 484 if (lcprevsolidtoken.tokencode == TBaseType.rrw_then) { 485 lcisnewsql = false; 486 } 487 } 488 } 489 490 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstGrant) { 491 if (TBaseType.assigned(lcprevsolidtoken)) { 492 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 493 lcisnewsql = false; 494 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 495 lcisnewsql = false; 496 } 497 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstRevoke) { 498 // Fix for issue #4315: REVOKE UPDATE should not split into two statements 499 if (TBaseType.assigned(lcprevsolidtoken)) { 500 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 501 lcisnewsql = false; 502 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 503 lcisnewsql = false; 504 } 505 } 506 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 507 if (TBaseType.assigned(lcprevsolidtoken)) { 508 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 509 lcisnewsql = false; 510 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 511 lcisnewsql = false; 512 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 513 lcisnewsql = false; 514 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 515 lcisnewsql = false; 516 } 517 } 518 519 } 520 } 521 522 if (lcisnewsql) { 523 ret = new TUpdateSqlStatement(this.vendor); 524 ret.dummytag = 1; // means set clause in update is not found yet, used to separate set clause from set statement 525 } 526 527 break; 528 } 529 case sstdelete: { 530 lcisnewsql = true; 531 532 if (pstate != EFindSqlStateType.stnormal) { 533 lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 534 if (TBaseType.assigned(lcprevsolidtoken)) { 535 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 536 lcisnewsql = false; 537 } 538 539 if (TBaseType.assigned(lccurrentsqlstatement)) { 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 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstGrant) { 550 if (TBaseType.assigned(lcprevsolidtoken)) { 551 if (lcprevsolidtoken.tokencode == TBaseType.rrw_grant) 552 lcisnewsql = false; 553 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 554 lcisnewsql = false; 555 } 556 } 557 558 // Fix for issue #4315: REVOKE DELETE should not split into two statements 559 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstRevoke) { 560 if (TBaseType.assigned(lcprevsolidtoken)) { 561 if (lcprevsolidtoken.tokencode == TBaseType.rrw_revoke) 562 lcisnewsql = false; 563 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 564 lcisnewsql = false; 565 } 566 } 567 568 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger) { 569 if (TBaseType.assigned(lcprevsolidtoken)) { 570 if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 571 lcisnewsql = false; 572 else if (lcprevsolidtoken.tokentype == ETokenType.ttcomma) 573 lcisnewsql = false; 574 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "after") == 0) 575 lcisnewsql = false; 576 else if (TBaseType.mycomparetext(lcprevsolidtoken.getAstext(), "of") == 0) 577 lcisnewsql = false; 578 } 579 } 580 581 if ((lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstbackupcatalogdelete) 582 || (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 583 ) { 584 lcisnewsql = false; 585 } 586 587 } 588 } 589 590 if (lcisnewsql) 591 ret = new TDeleteSqlStatement(this.vendor); 592 593 break; 594 } 595 case sstcreatetable: { 596 ret = new TCreateTableSqlStatement(this.vendor); 597 break; 598 } 599 case sstcreateview: { 600 ret = new TCreateViewSqlStatement(this.vendor); 601 break; 602 } 603 case sstcreatesequence: { 604 ret = new TCreateSequenceStmt(this.vendor); 605 break; 606 } 607 case sstaltertable: { 608 lcisnewsql = true; 609 if (pstate != EFindSqlStateType.stnormal) { 610 lcisnewsql = false; 611 } 612 if (lcisnewsql) { 613 ret = new TAlterTableStatement(this.vendor); 614 } 615 break; 616 } 617 case sstcreateprocedure: { 618 ret = new TCreateProcedureStmt(this.vendor); 619 break; 620 } 621 case sstalterprocedure: { 622 boolean isAlter = false; 623 // hana alter and create procedure 语法混在一起，无法区分 624 // c:\prg\gsp_java\gsp_java_core\gsp_sqlfiles\TestCases\public\allversions\hana\create_procedure.sql 625 if (pcst.tokencode == TBaseType.rrw_alter) { 626 627 TSourceToken st = pcst.nextSolidToken(3); 628 if (st != null) { 629 switch (st.toString().toUpperCase()) { 630 case "RECOMPILE": 631 isAlter = true; 632 break; 633 case "ENCRYPTION": 634 isAlter = true; 635 break; 636 case "ADD": 637 isAlter = true; 638 break; 639 default: 640 break; 641 } 642 } 643 } 644 if (isAlter) { 645 ret = new TAlterProcedureStmt(this.vendor); 646 } else { 647 ret = new TCreateProcedureStmt(this.vendor); 648 } 649 650 break; 651 } 652 case sstcreatefunction: { 653 ret = new TCreateFunctionStmt(this.vendor); 654 break; 655 } 656 case sstalterfunction: { 657 boolean isAlter = false; 658 // hana alter and create function 语法混在一起，无法区分 659 660 if (pcst.tokencode == TBaseType.rrw_alter) { 661 TSourceToken stAdd = pcst.searchToken("add", 4); 662 TSourceToken stAlter = pcst.searchToken("alter", 4); 663 TSourceToken stDrop = pcst.searchToken("drop", 4); 664 if ((stAdd != null) || (stAlter != null) || (stDrop != null)) { 665 isAlter = true; 666 } else { 667 TSourceToken st = pcst.searchToken("encryption", 4); 668 if (st != null) { 669 isAlter = true; 670 } 671 } 672 } 673 674 if (isAlter) { 675 ret = new TAlterFunctionStmt(this.vendor); 676 } else { 677 ret = new TCreateFunctionStmt(this.vendor); 678 } 679 680 681 break; 682 } 683 case sstcreatetrigger: 684 case sstaltertrigger: { 685 ret = new TCreateTriggerStmt(this.vendor); 686 break; 687 } 688 case sstGrant: { 689 lcisnewsql = true; 690 691 if (pstate != EFindSqlStateType.stnormal) { 692 lcisnewsql = false; 693 694 } 695 if (lcisnewsql) { 696 ret = new TGrantStmt(this.vendor); 697 for (k = lcpos + 1; k < lcsourcetokenlist.size(); k++) // iterate 698 { 699 lctoken = lcsourcetokenlist.get(k); 700 if (lctoken.isnonsolidtoken()) continue; 701 if (lctoken.tokencode == TBaseType.rrw_go) break; 702 if (lctoken.tokentype == ETokenType.ttsemicolon) break; 703 if (lctoken.tokencode == TBaseType.rrw_to) break; 704 lctoken.tokenstatus = ETokenStatus.tsignoredbygetrawstatement; 705 } 706 } 707 break; 708 } 709 case sstdropview: { 710 ret = new TDropViewSqlStatement(this.vendor); 711 break; 712 } 713 case sstdroptable: { 714 ret = new TDropTableSqlStatement(this.vendor); 715 break; 716 } 717 case sstdropindex: { 718 ret = new TDropIndexSqlStatement(this.vendor); 719 break; 720 } 721 case ssttruncatetable: { 722 ret = new TTruncateStatement(this.vendor); 723 break; 724 } 725 case sstcommit: { 726 lcisnewsql = true; 727 TSourceToken lcPrev = pcst.prevSolidToken(); 728 if ((lcPrev != null) && (lcPrev.tokencode == TBaseType.rrw_hana_of)) { 729 lcisnewsql = false; 730 } 731 if (pstate != EFindSqlStateType.stnormal) { 732 lcisnewsql = false; 733 734 } 735 if (lcisnewsql) { 736 ret = new TCommitStmt(this.vendor); 737 } 738 739 break; 740 } 741 case sstrollback: { 742 ret = new TRollbackStmt(this.vendor); 743 break; 744 } 745 case sstRevoke: { 746 lcisnewsql = true; 747 748 if (pstate != EFindSqlStateType.stnormal) { 749 lcisnewsql = false; 750 751 } 752 if (lcisnewsql) { 753 ret = new TRevokeStmt(this.vendor); 754 } 755 break; 756 } 757 case sstcreateindex: { 758 ret = new TCreateIndexSqlStatement(this.vendor); 759 break; 760 } 761 case sstset: { 762 lcisnewsql = true; 763 if (pstate != EFindSqlStateType.stnormal) { 764 if (TBaseType.assigned(lccurrentsqlstatement)) { 765 lcisnewsql = false; 766 } 767 } 768 769 if (lcisnewsql) { 770 ret = new TSetStmt(this.vendor); 771 } 772 773 break; 774 } 775 case sstdropsequence: 776 ret = new TDropSequenceStmt(this.vendor); 777 break; 778 case sstalterdatabase: 779 ret = new TAlterDatabaseStmt(this.vendor); 780 break; 781 case sstcreatedatabase: { 782 ret = new TCreateDatabaseSqlStatement(this.vendor); 783 break; 784 } 785 case sstcreateschema: { 786 ret = new TCreateSchemaSqlStatement(this.vendor); 787 break; 788 } 789 case sstcreatesynonym: { 790 ret = new TCreateSynonymStmt(this.vendor); 791 break; 792 } 793 case sstcreatetype: 794 ret = new TMssqlCreateType(this.vendor); 795 break; 796 case sstreplace: 797 lcisnewsql = true; 798 TSourceToken lcNext = pcst.nextSolidToken(); 799 if ((lcNext != null) && (lcNext.tokencode == '(')) { 800 lcisnewsql = false; 801 } 802 if (pstate != EFindSqlStateType.stnormal) { 803 lcisnewsql = false; 804 } 805 if (lcisnewsql) { 806 ret = new TUpsertStmt(this.vendor); 807 } 808 break; 809 case sstalterauditpolicy: 810 ret = new TAlterAuditPolicyStmt(this.vendor); 811 break; 812 case sstaltercredential: 813 ret = new TAlterCredentialStmt(this.vendor); 814 break; 815 case sstalterfulltextindex: 816 ret = new TAlterFulltextIndexStmt(this.vendor); 817 break; 818 case sstalterindex: 819 ret = new TAlterIndexStmt(this.vendor); 820 break; 821 case sstalterldapprovider: 822 ret = new TAlterLDAPProviderStmt(this.vendor); 823 break; 824 case sstalterjwtprovider: 825 ret = new TAlterJWTProviderStmt(this.vendor); 826 break; 827 case sstalterpse: 828 ret = new TAlterPSEStmt(this.vendor); 829 break; 830 case sstalterremotesource: 831 ret = new TAlterRemoteSourceStmt(this.vendor); 832 break; 833 case sstAlterRole: 834 ret = new TAlterRoleStmt(this.vendor); 835 break; 836 case sstaltersamlprovider: 837 ret = new TAlterSAMLProviderStmt(this.vendor); 838 break; 839 case sstaltersequence: 840 ret = new TAlterSequenceStatement(this.vendor); 841 break; 842 case sstalterstatistics: 843 ret = new TAlterStatisticsStmt(this.vendor); 844 break; 845 case sstaltersystem: 846 ret = new TAlterSystemStmt(this.vendor); 847 break; 848 case sstunload: 849 lcisnewsql = true; 850 if (pstate != EFindSqlStateType.stnormal) { 851 lcisnewsql = false; 852 } 853 if (lcisnewsql) { 854 ret = new TUnloadStmt(this.vendor); 855 ret.sqlstatementtype = gnewsqlstatementtype; 856 } 857 break; 858 case sstunset: 859 case sstunsetpse: 860 case sstunsetsystemlicense: 861 lcisnewsql = true; 862 if (pstate != EFindSqlStateType.stnormal) { 863 lcisnewsql = false; 864 } 865 if (lcisnewsql) { 866 ret = new TUnsetStmt(this.vendor); 867 ret.sqlstatementtype = gnewsqlstatementtype; 868 } 869 break; 870 case sstalteruser: 871 ret = new TAlterUserStmt(this.vendor); 872 break; 873 case sstconnect: 874 lcisnewsql = true; 875 if (pstate != EFindSqlStateType.stnormal) { 876 lcisnewsql = false; 877 } 878 if (lcisnewsql) { 879 ret = new TConnectStmt(this.vendor); 880 ret.sqlstatementtype = gnewsqlstatementtype; 881 } 882 break; 883 case sstalterusergroup: 884 ret = new TAlterUserGroupStmt(this.vendor); 885 break; 886 case sstalterview: 887 case sstalterviewcache: 888 ret = new TAlterViewStatement(this.vendor); 889 break; 890 case sstaltervirtualtable: 891 ret = new TAlterVirtualTableStmt(this.vendor); 892 break; 893 case sstalterworkloadclass: 894 ret = new TAlterWorkloadClassStmt(this.vendor); 895 break; 896 case sstalterworkloadmapping: 897 ret = new TAlterWorkloadMappingStmt(this.vendor); 898 break; 899 case sstbackupcancel: 900 ret = new TBackupCancelStmt(this.vendor); 901 break; 902 case sstbackupcatalogdelete: 903 ret = new TBackupCatalogDeleteStmt(this.vendor); 904 break; 905 case sstbackupcheck: 906 case sstbackupcheckaccess: 907 ret = new TBackupCheckStmt(this.vendor); 908 break; 909 case sstbackupdata: 910 ret = new TBackupDataStmt(this.vendor); 911 break; 912 case sstbackuplistdata: 913 ret = new TBackupListDataStmt(this.vendor); 914 break; 915 case sstcall: 916 ret = new TCallStatement(this.vendor); 917 break; 918 case sstcomment: 919 ret = new TCommentOnSqlStmt(this.vendor); 920 break; 921 case sstcreateauditpolicy: 922 ret = new TCreateAuditPolicyStmt(this.vendor); 923 break; 924 case sstcreatecertificate: 925 ret = new TCreateCertificateStmt(this.vendor); 926 break; 927 case sstcreatecollection: 928 ret = new TCreateCollectionStmt(this.vendor); 929 break; 930 case sstcreatecredential: 931 ret = new TCreateCredentialStmt(this.vendor); 932 break; 933 case sstcreatefulltextindex: 934 ret = new TCreateFulltextIndexStmt(this.vendor); 935 break; 936 case sstcreategraphworkspace: 937 ret = new TCreateGraphWorkspaceStmt(this.vendor); 938 break; 939 case sstcreateJWTProvider: 940 ret = new TCreateJWTProviderStmt(this.vendor); 941 break; 942 case sstcreateLDAPProvider: 943 ret = new TCreateLDAPProviderStmt(this.vendor); 944 break; 945 case sstcreatepse: 946 ret = new TCreatePSEStmt(this.vendor); 947 break; 948 case sstcreateremotesource: 949 ret = new TCreateRemoteSourceStmt(this.vendor); 950 break; 951 case sstcreaterole: 952 ret = new TCreateRoleStmt(this.vendor); 953 break; 954 case sstcreatesamlprovider: 955 ret = new TCreateSAMLProviderStmt(this.vendor); 956 break; 957 case sstcreatestatistics: 958 ret = new TCreateStatistics(this.vendor); 959 break; 960 case sstcreatestructuredprivilege: 961 ret = new TCreateStructuredPrivilegeStmt(this.vendor); 962 break; 963 case sstcreateuser: 964 ret = new TCreateUserStmt(this.vendor); 965 break; 966 case sstcreateusergroup: 967 ret = new TCreateUserGroupStmt(this.vendor); 968 break; 969 case sstcreatevirtualfunction: 970 ret = new TCreateVirtualFunctionStmt(this.vendor); 971 break; 972 case sstcreatevirtualtable: 973 ret = new TCreateVirtualTableStmt(this.vendor); 974 break; 975 case sstcreateworkloadclass: 976 ret = new TCreateWorkloadClassStmt(this.vendor); 977 break; 978 case sstcreateworkloadmapping: 979 ret = new TCreateWorkloadMappingStmt(this.vendor); 980 break; 981 case sstdropauditpolicy: 982 case sstdropcertificate: 983 case sstdropcollection: 984 case sstdropcredential: 985 case sstdropfulltextindex: 986 case sstdropJWTProvider: 987 case sstdropLDAPProvider: 988 case sstdroppse: 989 case sstdropremotesource: 990 case sstdropsamlprovider: 991 case sstdropstatistics: 992 case sstdropgraphworkspace: 993 case sstdropstructuredprivilege: 994 case sstdroptype: 995 case sstdropusergroup: 996 case sstdropworkloadclass: 997 case sstdropworkloadmapping: 998 lcisnewsql = true; 999 if (pstate != EFindSqlStateType.stnormal) { 1000 lcisnewsql = false; 1001 } 1002 if (lcisnewsql) { 1003 ret = new TDropStmt(this.vendor); 1004 } 1005 1006 break; 1007 case sstdropdatabase: 1008 ret = new TDropDatabaseStmt(this.vendor); 1009 break; 1010 case sstdropfunction: 1011 ret = new TDropFunctionStmt(this.vendor); 1012 break; 1013 case sstdropprocedure: 1014 ret = new TDropProcedureStmt(this.vendor); 1015 break; 1016 case sstdroprole: 1017 ret = new TDropRoleStmt(this.vendor); 1018 break; 1019 case sstdropschema: 1020 ret = new TDropSchemaSqlStatement(this.vendor); 1021 break; 1022 case sstdropsynonym: 1023 ret = new TDropSynonymStmt(this.vendor); 1024 break; 1025 case sstdroptrigger: 1026 ret = new TDropTriggerSqlStatement(this.vendor); 1027 break; 1028 case sstdropuser: 1029 ret = new TDropUserStmt(this.vendor); 1030 break; 1031 case sstExplain: 1032 ret = new TExplainPlan(this.vendor); 1033 break; 1034 case sstexport: 1035 ret = new TExportStmt(this.vendor); 1036 break; 1037 case sstimport: 1038 ret = new TImportStmt(this.vendor); 1039 break; 1040 case sstload: 1041 lcisnewsql = true; 1042 if (pstate != EFindSqlStateType.stnormal) { 1043 lcisnewsql = false; 1044 } 1045 if (lcisnewsql) { 1046 ret = new TLoadStmt(this.vendor); 1047 } 1048 1049 break; 1050 case sstlocktable: 1051 ret = new TLockTableStmt(this.vendor); 1052 break; 1053 case sstmergedelta: 1054 ret = new TMergeDeltaStmt(this.vendor); 1055 break; 1056 case sstmerge: 1057 ret = new TMergeSqlStatement(this.vendor); 1058 break; 1059 case sstrecoverdata: 1060 ret = new TRecoverDataStmt(this.vendor); 1061 break; 1062 case sstrecoverdatabase: 1063 ret = new TRecoverDatabaseStmt(this.vendor); 1064 break; 1065 case sstrefreshstatistics: 1066 ret = new TRefreshStatisticsStmt(this.vendor); 1067 break; 1068 case sstrenamecollection: 1069 case sstrenamecolumn: 1070 case sstrenamedatabase: 1071 case sstrenameindex: 1072 case sstrenametable: 1073 ret = new TRenameStmt(this.vendor); 1074 break; 1075 case sssethistorysession: 1076 case sstsetpse: 1077 case sstsetschema: 1078 case sstsetsystemlicense: 1079 case sstsettransaction: 1080 case sstsettransactionautocommit: 1081 ret = new TSetDatabaseObjectStmt(this.vendor); 1082 break; 1083 case ssttruncatecollection: 1084 ret = new TTruncateCollectionStmt(this.vendor); 1085 break; 1086 case sstvalidateLDAPProvider: 1087 ret = new TValidateLDAPProviderStmt(this.vendor); 1088 break; 1089 case sstvalidateUser: 1090 ret = new TValidateUserStmt(this.vendor); 1091 break; 1092 case sstupsert: 1093 ret = new TUpsertStmt(this.vendor); 1094 break; 1095 case sstsavepoint: { 1096 lcisnewsql = true; 1097 1098 if (pstate != EFindSqlStateType.stnormal) { 1099 lcisnewsql = false; 1100 1101 } 1102 if (lcisnewsql) { 1103 ret = new TSavepointStmt(this.vendor); 1104 ret.sqlstatementtype = gnewsqlstatementtype; 1105 } 1106 break; 1107 } 1108 default: { 1109 ret = new TUnknownSqlStatement(this.vendor); 1110 ret.sqlstatementtype = gnewsqlstatementtype; 1111 break; 1112 } 1113 } // case 1114 1115 return ret; 1116 } 1117}