001package gudusoft.gsqlparser.sqlcmds; 002 003import gudusoft.gsqlparser.*; 004import gudusoft.gsqlparser.stmt.*; 005import gudusoft.gsqlparser.stmt.db2.*; 006 007/** 008 * DB2 SQL command resolver. 009 * Handles DB2-specific statement recognition. 010 * 011 * @since 3.1.0.9 012 */ 013public class TSqlCmdsDb2 extends AbstractSqlCmds { 014 015 public TSqlCmdsDb2() { 016 super(EDbVendor.dbvdb2); 017 } 018 019 @Override 020 protected String getToken1Str(int token1) { 021 // Handle DB2-specific reserved words (token codes > TBaseType.rrw_abort) 022 switch (token1) { 023 case TBaseType.rrw_db2_label: 024 return "label"; 025 case TBaseType.rrw_db2_runstats: 026 return "runstats"; 027 default: 028 return null; 029 } 030 } 031 032 @Override 033 protected void initializeCommands() { 034 // DB2 commands must be sorted alphabetically by token1 035 036 addCmd(TBaseType.rrw_allocate, "cursor", ESqlStatementType.sstdb2allocatecursor); 037 addCmd(TBaseType.rrw_allocate, "*", "cursor", ESqlStatementType.sstdb2allocatecursor); 038 039 // ALTER commands 040 addCmd(TBaseType.rrw_alter, "bufferpool", ESqlStatementType.sstdb2alterbufferpool); 041 addCmd(TBaseType.rrw_alter, "database", "partition", "group", ESqlStatementType.sstdb2alterdatabasepartitiongroup); 042 addCmd(TBaseType.rrw_alter, "database", ESqlStatementType.sstdb2alterdatabase); 043 addCmd(TBaseType.rrw_alter, "function", ESqlStatementType.sstdb2alterfunction); 044 addCmd(TBaseType.rrw_alter, "index", ESqlStatementType.sstdb2alterindex); 045 addCmd(TBaseType.rrw_alter, "mask", ESqlStatementType.sstdb2altermask); 046 addCmd(TBaseType.rrw_alter, "permission", ESqlStatementType.sstdb2alterpermission); 047 addCmd(TBaseType.rrw_alter, "specific", "function", ESqlStatementType.sstdb2alterfunction); 048 addCmd(TBaseType.rrw_alter, "specific", "procedure", ESqlStatementType.sstdb2alterprocedure); 049 addCmd(TBaseType.rrw_alter, "stogroup", ESqlStatementType.sstdb2alterstogroup); 050 addCmd(TBaseType.rrw_alter, "trigger", ESqlStatementType.sstdb2altertrigger); 051 addCmd(TBaseType.rrw_alter, "trusted", "context", ESqlStatementType.sstdb2altertrustedcontext); 052 addCmd(TBaseType.rrw_alter, "method", ESqlStatementType.sstdb2altermethod); 053 addCmd(TBaseType.rrw_alter, "nickname", ESqlStatementType.sstdb2alternickname); 054 addCmd(TBaseType.rrw_alter, "procedure", ESqlStatementType.sstdb2alterprocedure); 055 addCmd(TBaseType.rrw_alter, "sequence", ESqlStatementType.sstdb2altersequence); 056 addCmd(TBaseType.rrw_alter, "server", ESqlStatementType.sstdb2alterserver); 057 addCmd(TBaseType.rrw_alter, "table", ESqlStatementType.sstaltertable); 058 addCmd(TBaseType.rrw_alter, "tablespace", ESqlStatementType.sstdb2altertablespace); 059 addCmd(TBaseType.rrw_alter, "type", ESqlStatementType.sstdb2altertype); 060 addCmd(TBaseType.rrw_alter, "user", "mapping", ESqlStatementType.sstdb2alterusermapping); 061 addCmd(TBaseType.rrw_alter, "view", ESqlStatementType.sstdb2alterview); 062 addCmd(TBaseType.rrw_alter, "wrapper", ESqlStatementType.sstdb2alterwrapper); 063 064 addCmd(TBaseType.rrw_associate, "locators", ESqlStatementType.sstdb2associatelocators); 065 addCmd(TBaseType.rrw_associate, "result", "set", "locator", ESqlStatementType.sstdb2associatelocators); 066 addCmd(TBaseType.rrw_associate, "result", "set", "locators", ESqlStatementType.sstdb2associatelocators); 067 addCmd(TBaseType.rrw_begin, "declare", "section", ESqlStatementType.sstdb2begindeclaresection); 068 addCmd(TBaseType.rrw_call, ESqlStatementType.sstdb2call); 069 addCmd(TBaseType.rrw_case, ESqlStatementType.sstdb2case); 070 addCmd(TBaseType.rrw_close, ESqlStatementType.sstdb2close); 071 addCmd(TBaseType.rrw_comment, ESqlStatementType.sstdb2comment); 072 addCmd(TBaseType.rrw_commit, ESqlStatementType.sstdb2commit); 073 addCmd(TBaseType.rrw_connect, ESqlStatementType.sstdb2connect); 074 075 // CREATE commands - Note: longer patterns BEFORE shorter ones 076 addCmd(TBaseType.rrw_create, "or", "replace", "public", "alias", ESqlStatementType.sstdb2createalias); 077 addCmd(TBaseType.rrw_create, "or", "replace", "alias", ESqlStatementType.sstdb2createalias); 078 addCmd(TBaseType.rrw_create, "or", "replace", "function", ESqlStatementType.sstcreatefunction); 079 addCmd(TBaseType.rrw_create, "or", "replace", "procedure", ESqlStatementType.sstcreateprocedure); 080 addCmd(TBaseType.rrw_create, "or", "replace", "trigger", ESqlStatementType.sstdb2createtrigger); 081 addCmd(TBaseType.rrw_create, "or", "replace", "variable", ESqlStatementType.sstdb2createvariable); 082 addCmd(TBaseType.rrw_create, "or", "replace", "view", ESqlStatementType.sstcreateview); 083 addCmd(TBaseType.rrw_create, "global", "temporary", "table", ESqlStatementType.sstcreatetable); 084 addCmd(TBaseType.rrw_create, "large", "tablespace", ESqlStatementType.sstcreateTablespace); 085 addCmd(TBaseType.rrw_create, "database", "partition", "group", ESqlStatementType.sstdb2createdatabasepartitiongroup); 086 addCmd(TBaseType.rrw_create, "distinct", "type", ESqlStatementType.sstdb2createdistincttype); 087 addCmd(TBaseType.rrw_create, "function", "mapping", ESqlStatementType.sstdb2createfunctionmapping); 088 addCmd(TBaseType.rrw_create, "index", "extension", ESqlStatementType.sstdb2createindexextension); 089 addCmd(TBaseType.rrw_create, "type", "mapping", ESqlStatementType.sstdb2createtypemapping); 090 addCmd(TBaseType.rrw_create, "user", "mapping", ESqlStatementType.sstdb2createusermapping); 091 addCmd(TBaseType.rrw_create, "audit", "policy", ESqlStatementType.sstcreateauditpolicy); 092 addCmd(TBaseType.rrw_create, "aux", "table", ESqlStatementType.sstdb2createauxiliarytable); 093 addCmd(TBaseType.rrw_create, "auxiliary", "table", ESqlStatementType.sstdb2createauxiliarytable); 094 addCmd(TBaseType.rrw_create, "lob", "tablespace", ESqlStatementType.sstdb2createlobtablespace); 095 addCmd(TBaseType.rrw_create, "mask", ESqlStatementType.sstdb2createmask); 096 addCmd(TBaseType.rrw_create, "permission", ESqlStatementType.sstdb2createpermission); 097 addCmd(TBaseType.rrw_create, "trusted", "context", ESqlStatementType.sstdb2createtrustedcontext); 098 addCmd(TBaseType.rrw_create, "public", "alias", ESqlStatementType.sstdb2createalias); 099 addCmd(TBaseType.rrw_create, "public", "synonym", ESqlStatementType.sstcreatesynonym); 100 addCmd(TBaseType.rrw_create, "summary", "table", ESqlStatementType.sstcreatetable); 101 addCmd(TBaseType.rrw_create, "alias", ESqlStatementType.sstdb2createalias); 102 addCmd(TBaseType.rrw_create, "bufferpool", ESqlStatementType.sstdb2createbufferpool); 103 addCmd(TBaseType.rrw_create, "database", ESqlStatementType.sstcreatedatabase); 104 addCmd(TBaseType.rrw_create, "eventmonitor", ESqlStatementType.sstdb2createeventmonitor); 105 addCmd(TBaseType.rrw_create, "function", ESqlStatementType.sstcreatefunction); 106 addCmd(TBaseType.rrw_create, "index", ESqlStatementType.sstcreateindex); 107 addCmd(TBaseType.rrw_create, "method", ESqlStatementType.sstdb2createmethod); 108 addCmd(TBaseType.rrw_create, "nickname", ESqlStatementType.sstdb2createnickname); 109 addCmd(TBaseType.rrw_create, "procedure", ESqlStatementType.sstcreateprocedure); 110 addCmd(TBaseType.rrw_create, "role", ESqlStatementType.sstcreaterole); 111 addCmd(TBaseType.rrw_create, "schema", ESqlStatementType.sstdb2createschema); 112 addCmd(TBaseType.rrw_create, "sequence", ESqlStatementType.sstdb2createsequence); 113 addCmd(TBaseType.rrw_create, "server", ESqlStatementType.sstdb2createserver); 114 addCmd(TBaseType.rrw_create, "stogroup", ESqlStatementType.sstdb2createstogroup); 115 addCmd(TBaseType.rrw_create, "synonym", ESqlStatementType.sstcreatesynonym); 116 addCmd(TBaseType.rrw_create, "table", ESqlStatementType.sstcreatetable); 117 addCmd(TBaseType.rrw_create, "tablespace", ESqlStatementType.sstcreateTablespace); 118 addCmd(TBaseType.rrw_create, "transform", ESqlStatementType.sstdb2createtransform); 119 addCmd(TBaseType.rrw_create, "trigger", ESqlStatementType.sstdb2createtrigger); 120 addCmd(TBaseType.rrw_create, "type", ESqlStatementType.sstdb2createtype); 121 addCmd(TBaseType.rrw_create, "variable", ESqlStatementType.sstdb2createvariable); 122 addCmd(TBaseType.rrw_create, "view", ESqlStatementType.sstcreateview); 123 addCmd(TBaseType.rrw_create, "wrapper", ESqlStatementType.sstdb2createwrapper); 124 addCmd(TBaseType.rrw_create, "*", "index", ESqlStatementType.sstcreateindex); 125 126 // DECLARE commands 127 // NOTE: the DB2 splitter rewrites the leading DECLARE token of 128 // "DECLARE GLOBAL ..." to rrw_declare_global BEFORE issql() runs 129 // (Db2SqlParser.getrawsqlstatements token transformation), so the 130 // pattern must be registered under rrw_declare_global, not rrw_declare. 131 addCmd(TBaseType.rrw_declare_global, "global", "temporary", "table", ESqlStatementType.sstdb2declareglobaltemporarytable); 132 addCmd(TBaseType.rrw_declare, "*", "cursor", ESqlStatementType.sstdb2declarecursor); 133 // cursor-name followed by sensitivity/scroll modifiers before CURSOR 134 addCmd(TBaseType.rrw_declare, "*", "*", "cursor", ESqlStatementType.sstdb2declarecursor); 135 addCmd(TBaseType.rrw_declare, "*", "*", "*", "cursor", ESqlStatementType.sstdb2declarecursor); 136 addCmd(TBaseType.rrw_declare, "*", "*", "*", "*", "cursor", ESqlStatementType.sstdb2declarecursor); 137 addCmd(TBaseType.rrw_declare, "*", "statement", ESqlStatementType.sstdb2declarestatement); 138 addCmd(TBaseType.rrw_declare, "*", "variable", ESqlStatementType.sstdb2declarevariable); 139 addCmd(TBaseType.rrw_declare, "table", ESqlStatementType.sstdb2declaretable); 140 addCmd(TBaseType.rrw_declare, "*", "table", ESqlStatementType.sstdb2declaretable); 141 addCmd(TBaseType.rrw_declare, "*", "*", "*", "table", ESqlStatementType.sstdb2declaretable); 142 143 addCmd(TBaseType.rrw_delete, ESqlStatementType.sstdelete); 144 addCmd(TBaseType.rrw_describe, ESqlStatementType.sstdb2describe); 145 addCmd(TBaseType.rrw_disconnect, ESqlStatementType.sstdb2disconnect); 146 147 // DROP commands - longer patterns first 148 addCmd(TBaseType.rrw_drop, "index", ESqlStatementType.sstdropindex); 149 addCmd(TBaseType.rrw_drop, "table", ESqlStatementType.sstdroptable); 150 addCmd(TBaseType.rrw_drop, "view", ESqlStatementType.sstdropview); 151 addCmd(TBaseType.rrw_drop, ESqlStatementType.sstdb2drop); 152 153 addCmd(TBaseType.rrw_end, "declare", "section", ESqlStatementType.sstdb2enddeclaresection); 154 155 // EXECUTE commands 156 addCmd(TBaseType.rrw_execute, "immediate", ESqlStatementType.sstdb2executeimmediate); 157 addCmd(TBaseType.rrw_execute, ESqlStatementType.sstdb2execute); 158 159 addCmd(TBaseType.rrw_explain, ESqlStatementType.sstdb2explain); 160 addCmd(TBaseType.rrw_fetch, ESqlStatementType.sstdb2fetch); 161 162 // FLUSH commands 163 addCmd(TBaseType.rrw_flush, "event", "monitor", ESqlStatementType.sstdb2flusheventmonitor); 164 addCmd(TBaseType.rrw_flush, "package", "cache", ESqlStatementType.sstdb2flushpackagecache); 165 166 addCmd(TBaseType.rrw_for, ESqlStatementType.sstdb2for); 167 addCmd(TBaseType.rrw_free, "locator", ESqlStatementType.sstdb2freelocator); 168 addCmd(TBaseType.rrw_get, "diagnostics", ESqlStatementType.sstgetdiagnostics); 169 addCmd(TBaseType.rrw_get, "current", "diagnostics", ESqlStatementType.sstgetdiagnostics); 170 addCmd(TBaseType.rrw_get, "stacked", "diagnostics", ESqlStatementType.sstgetdiagnostics); 171 addCmd(TBaseType.rrw_goto, ESqlStatementType.sstdb2goto); 172 addCmd(TBaseType.rrw_grant, ESqlStatementType.sstdb2grant); 173 addCmd(TBaseType.rrw_if, ESqlStatementType.sstdb2if); 174 addCmd(TBaseType.rrw_include, ESqlStatementType.sstdb2include); 175 addCmd(TBaseType.rrw_insert, ESqlStatementType.sstinsert); 176 addCmd(TBaseType.rrw_iterate, ESqlStatementType.sstdb2iterate); 177 addCmd(TBaseType.rrw_db2_label, "on", ESqlStatementType.sstdb2labelOn); 178 addCmd(TBaseType.rrw_leave, ESqlStatementType.sstdb2leave); 179 addCmd(TBaseType.rrw_lock, "table", ESqlStatementType.sstdb2locktable); 180 addCmd(TBaseType.rrw_loop, ESqlStatementType.sstdb2loop); 181 addCmd(TBaseType.rrw_merge, ESqlStatementType.sstmerge); 182 addCmd(TBaseType.rrw_open, ESqlStatementType.sstdb2open); 183 addCmd(TBaseType.rrw_prepare, ESqlStatementType.sstdb2prepare); 184 addCmd(TBaseType.rrw_refresh, "table", ESqlStatementType.sstdb2refreshtable); 185 186 // RELEASE commands 187 addCmd(TBaseType.rrw_release, "savepoint", ESqlStatementType.sstdb2releasesavepoint); 188 addCmd(TBaseType.rrw_release, ESqlStatementType.sstdb2release); 189 190 // RENAME commands 191 addCmd(TBaseType.rrw_rename, "tablespace", ESqlStatementType.sstdb2renametablespace); 192 addCmd(TBaseType.rrw_rename, ESqlStatementType.sstdb2rename); 193 194 addCmd(TBaseType.rrw_repeat, ESqlStatementType.sstdb2repeat); 195 addCmd(TBaseType.rrw_resignal, ESqlStatementType.sstdb2resignal); 196 addCmd(TBaseType.rrw_return, ESqlStatementType.sstdb2return); 197 addCmd(TBaseType.rrw_revoke, ESqlStatementType.sstdb2revoke); 198 addCmd(TBaseType.rrw_rollback, ESqlStatementType.sstdb2rollback); 199 addCmd(TBaseType.rrw_db2_runstats, ESqlStatementType.sstRunStats); 200 addCmd(TBaseType.rrw_savepoint, ESqlStatementType.sstdb2savepoint); 201 addCmd(TBaseType.rrw_select, ESqlStatementType.sstselect); 202 203 // SET commands - longer patterns first 204 addCmd(TBaseType.rrw_set, "current", "application", "encoding", "scheme", ESqlStatementType.sstdb2setcurrentapplicationencodingscheme); 205 addCmd(TBaseType.rrw_set, "current", "decfloat", "rounding", "mode", ESqlStatementType.sstdb2setcurrentdecfloatroundingmode); 206 addCmd(TBaseType.rrw_set, "current", "application", "compatibility", ESqlStatementType.sstdb2setcurrentapplicationcompatibility); 207 addCmd(TBaseType.rrw_set, "current", "debug", "mode", ESqlStatementType.sstdb2setcurrentdebugmode); 208 addCmd(TBaseType.rrw_set, "current", "encoding", "scheme", ESqlStatementType.sstdb2setcurrentapplicationencodingscheme); 209 addCmd(TBaseType.rrw_set, "current", "optimization", "hint", ESqlStatementType.sstdb2setcurrentoptimizationhint); 210 addCmd(TBaseType.rrw_set, "current", "query", "acceleration", ESqlStatementType.sstdb2setcurrentqueryacceleration); 211 addCmd(TBaseType.rrw_set, "current", "routine", "version", ESqlStatementType.sstdb2setcurrentroutineversion); 212 addCmd(TBaseType.rrw_set, "current", "temporal", "business_time", ESqlStatementType.sstdb2setcurrenttemporalbusinesstime); 213 addCmd(TBaseType.rrw_set, "current", "temporal", "system_time", ESqlStatementType.sstdb2setcurrenttemporalsystemtime); 214 addCmd(TBaseType.rrw_set, "current", "accelerator", ESqlStatementType.sstdb2setcurrentaccelerator); 215 addCmd(TBaseType.rrw_set, "current", "get_accel_archive", ESqlStatementType.sstdb2setcurrentgetaccelarchive); 216 addCmd(TBaseType.rrw_set, "current", "locale", ESqlStatementType.sstdb2setcurrentlocale); 217 addCmd(TBaseType.rrw_set, "current", "precision", ESqlStatementType.sstdb2setcurrentprecision); 218 addCmd(TBaseType.rrw_set, "current", "rules", ESqlStatementType.sstdb2setcurrentrules); 219 addCmd(TBaseType.rrw_set, "session", "time", "zone", ESqlStatementType.sstdb2setsessiontimezone); 220 addCmd(TBaseType.rrw_set, "current", "default", "transform", "group", ESqlStatementType.sstdb2setcurrentdefaulttransformgroup); 221 addCmd(TBaseType.rrw_set, "current", "maintained", "table", "types", ESqlStatementType.sstdb2setcurrentmaintainedtabletypesforoptimization); 222 addCmd(TBaseType.rrw_set, "current", "explain", "snapshot", ESqlStatementType.sstdb2setcurrentexplainsnapshot); 223 addCmd(TBaseType.rrw_set, "current", "explain", "mode", ESqlStatementType.sstdb2setcurrentexplainmode); 224 addCmd(TBaseType.rrw_set, "current", "lock", "timeout", ESqlStatementType.sstdb2setcurrentlocktimeout); 225 addCmd(TBaseType.rrw_set, "current", "package", "path", ESqlStatementType.sstdb2setcurrentpackagepath); 226 addCmd(TBaseType.rrw_set, "current", "query", "optimization", ESqlStatementType.sstdb2setcurrentqueryoptimization); 227 addCmd(TBaseType.rrw_set, "current", "refresh", "age", ESqlStatementType.sstdb2setcurrentrefreshage); 228 addCmd(TBaseType.rrw_set, "encryption", "password", ESqlStatementType.sstdb2setencryptionpassword); 229 addCmd(TBaseType.rrw_set, "event", "monitor", "state", ESqlStatementType.sstdb2seteventmonitorstate); 230 addCmd(TBaseType.rrw_set, "server", "option", ESqlStatementType.sstdb2setserveroption); 231 addCmd(TBaseType.rrw_set, "session", "authorization", ESqlStatementType.sstdb2setsessionauthorization); 232 addCmd(TBaseType.rrw_set, "current", "degree", ESqlStatementType.sstdb2setcurrentdegree); 233 addCmd(TBaseType.rrw_set, "current", "isolation", ESqlStatementType.sstdb2setcurrentisolation); 234 addCmd(TBaseType.rrw_set, "current", "packageset", ESqlStatementType.sstdb2setcurrentpackageset); 235 addCmd(TBaseType.rrw_set, "current", "schema", ESqlStatementType.sstdb2setschema); 236 addCmd(TBaseType.rrw_set, "connection", ESqlStatementType.sstdb2setconnection); 237 addCmd(TBaseType.rrw_set, "integrity", ESqlStatementType.sstdb2setintegrity); 238 addCmd(TBaseType.rrw_set, "passthru", ESqlStatementType.sstdb2setpassthru); 239 addCmd(TBaseType.rrw_set, "path", ESqlStatementType.sstdb2setpath); 240 addCmd(TBaseType.rrw_set, "schema", ESqlStatementType.sstdb2setschema); 241 addCmd(TBaseType.rrw_set, ESqlStatementType.sstdb2set); 242 243 addCmd(TBaseType.rrw_signal, ESqlStatementType.sstdb2signal); 244 addCmd(TBaseType.rrw_terminate, ESqlStatementType.sstdb2terminate); 245 addCmd(TBaseType.rrw_truncate, ESqlStatementType.ssttruncatetable); 246 247 // UPDATE commands 248 addCmd(TBaseType.rrw_update, "command", ESqlStatementType.sstdb2updateCommand); 249 addCmd(TBaseType.rrw_update, ESqlStatementType.sstupdate); 250 251 addCmd(TBaseType.rrw_while, ESqlStatementType.sstdb2while); 252 } 253 254 @Override 255 public TCustomSqlStatement issql(TSourceToken pcst, EFindSqlStateType pstate, TCustomSqlStatement psqlstatement) { 256 TCustomSqlStatement ret = null; 257 int k; 258 boolean lcisnewsql; 259 TSourceToken lcpprevsolidtoken, lcnextsolidtoken; 260 261 gnewsqlstatementtype = ESqlStatementType.sstinvalid; 262 263 if ((pcst.tokencode == TBaseType.cmtdoublehyphen) 264 || (pcst.tokencode == TBaseType.cmtslashstar) 265 || (pcst.tokencode == TBaseType.lexspace) 266 || (pcst.tokencode == TBaseType.lexnewline) 267 || (pcst.tokentype == ETokenType.ttsemicolon)) { 268 return ret; 269 } 270 271 int lcpos = pcst.posinlist; 272 TSourceTokenList lcsourcetokenlist = pcst.container; 273 TCustomSqlStatement lccurrentsqlstatement = psqlstatement; 274 275 // subquery after semicolon || at first line 276 if ((pstate == EFindSqlStateType.stnormal) && (pcst.tokentype == ETokenType.ttleftparenthesis)) { // ( 277 k = lcsourcetokenlist.solidtokenafterpos(lcpos, TBaseType.rrw_select, 1, "("); 278 if (k > 0) { 279 ret = new TSelectSqlStatement(this.vendor); 280 } 281 282 return ret; 283 } 284 285 // cte 286 if ((pstate == EFindSqlStateType.stnormal) && (pcst.tokencode == TBaseType.rrw_with)) { 287 ret = findcte(pcst); 288 if (TBaseType.assigned(ret)) return ret; 289 } 290 291 // values 292 if ((pstate == EFindSqlStateType.stnormal) && (pcst.tokencode == TBaseType.rrw_values)) { 293 ret = new TSelectSqlStatement(this.vendor); 294 return ret; 295 } 296 297 // db2 scriptoptions 298 if (pcst.tokencode == TBaseType.scriptoptions) { 299 ret = new TDb2ScriptOptionStmt(this.vendor); 300 return ret; 301 } 302 303 // Statements whose leading word has no stable raw token constant 304 // (WHENEVER/HOLD are vendor lexer keywords whose yacc values shift when 305 // tokens are added; EXCHANGE/TRANSFER tokenize as identifiers), so they 306 // are matched by text here instead of via the addCmd token table. 307 if (pstate == EFindSqlStateType.stnormal) { 308 String lcleadtext = pcst.toString(); 309 TSourceToken lcnextsolid = pcst.nextSolidToken(); 310 String lcnexttext = lcnextsolid == null ? "" : lcnextsolid.toString(); 311 ESqlStatementType lctexttype = null; 312 // non-identifier-compare: leading statement keywords, not object names 313 if (lcleadtext.equalsIgnoreCase("whenever")) { 314 lctexttype = ESqlStatementType.sstdb2whenever; 315 } else if (lcleadtext.equalsIgnoreCase("hold") && lcnexttext.equalsIgnoreCase("locator")) { 316 lctexttype = ESqlStatementType.sstdb2holdlocator; 317 } else if (lcleadtext.equalsIgnoreCase("exchange") && lcnexttext.equalsIgnoreCase("data")) { 318 lctexttype = ESqlStatementType.sstdb2exchangedata; 319 } else if (lcleadtext.equalsIgnoreCase("transfer") && lcnexttext.equalsIgnoreCase("ownership")) { 320 lctexttype = ESqlStatementType.sstdb2transferownership; 321 } 322 if (lctexttype != null) { 323 gnewsqlstatementtype = lctexttype; 324 ret = new TUnknownSqlStatement(this.vendor); 325 ret.sqlstatementtype = lctexttype; 326 return ret; 327 } 328 } 329 330 gnewsqlstatementtype = getStatementTypeForToken(pcst); 331 332 TSourceToken lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 333 switch (gnewsqlstatementtype) { 334 case sstinvalid: { 335 ret = null; 336 if (pcst.tokencode == TBaseType.rrw_begin) { 337 ret = new TCommonBlock(this.vendor); 338 gnewsqlstatementtype = ret.sqlstatementtype; 339 } 340 break; 341 } 342 case sstselect: { 343 lcisnewsql = true; 344 345 if (pstate != EFindSqlStateType.stnormal) { 346 if (TBaseType.assigned(lcprevsolidtoken)) { 347 if (lcprevsolidtoken.tokentype == ETokenType.ttleftparenthesis) 348 lcisnewsql = false; // subquery 349 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_union) 350 lcisnewsql = false; 351 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_intersect) 352 lcisnewsql = false; 353 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_minus) 354 lcisnewsql = false; 355 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_except) 356 lcisnewsql = false; 357 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_return) 358 lcisnewsql = false; 359 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_as) { 360 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 361 lcisnewsql = false; 362 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 363 lcisnewsql = false; 364 } 365 366 if (lcisnewsql && (lcprevsolidtoken.tokencode == TBaseType.rrw_all)) { 367 lcpprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcprevsolidtoken.posinlist); 368 if (TBaseType.assigned(lcpprevsolidtoken)) { 369 if (lcpprevsolidtoken.tokencode == TBaseType.rrw_union) 370 lcisnewsql = false; 371 } 372 } 373 } 374 375 if (TBaseType.assigned(lccurrentsqlstatement)) { 376 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) { 377 lcisnewsql = false; 378 } else if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstselect) { 379 if (lccurrentsqlstatement.isctequery) 380 lcisnewsql = false; 381 } 382 } 383 } 384 385 if (lcisnewsql) 386 ret = new TSelectSqlStatement(this.vendor); 387 break; 388 } 389 case sstinsert: { 390 lcisnewsql = true; 391 if (pstate != EFindSqlStateType.stnormal) { 392 if (TBaseType.assigned(lccurrentsqlstatement)) { 393 } 394 } 395 396 if (lcisnewsql) 397 ret = new TInsertSqlStatement(this.vendor); 398 break; 399 } 400 case sstupdate: { 401 lcisnewsql = true; 402 if (pstate != EFindSqlStateType.stnormal) { 403 lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 404 if (TBaseType.assigned(lcprevsolidtoken)) { 405 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 406 lcisnewsql = false; 407 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 408 lcisnewsql = false; 409 } 410 411 lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 412 if (TBaseType.assigned(lcnextsolidtoken)) { 413 if (lcnextsolidtoken.tokentype == ETokenType.ttleftparenthesis) { 414 k = lcsourcetokenlist.solidtokenafterpos(lcnextsolidtoken.posinlist, TBaseType.rrw_select, 1, "("); 415 if (k == 0) lcisnewsql = false; 416 } 417 } 418 419 if (TBaseType.assigned(lccurrentsqlstatement)) { 420 } 421 } 422 423 if (lcisnewsql) { 424 ret = new TUpdateSqlStatement(this.vendor); 425 ret.dummytag = 1; // means set clause in update is not found yet, used to separate set clause from set statement 426 } 427 break; 428 } 429 case sstdelete: { 430 lcisnewsql = true; 431 432 if (pstate != EFindSqlStateType.stnormal) { 433 lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 434 if (TBaseType.assigned(lcprevsolidtoken)) { 435 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 436 lcisnewsql = false; 437 } 438 439 if (TBaseType.assigned(lccurrentsqlstatement)) { 440 } 441 } 442 443 if (lcisnewsql) 444 ret = new TDeleteSqlStatement(this.vendor); 445 break; 446 } 447 case sstmerge: { 448 ret = new TMergeSqlStatement(this.vendor); 449 ret.sqlstatementtype = gnewsqlstatementtype; 450 break; 451 } 452 case sstcommit: { 453 ret = new TUnknownSqlStatement(this.vendor); 454 ret.sqlstatementtype = gnewsqlstatementtype; 455 break; 456 } 457 case sstrollback: { 458 ret = new TUnknownSqlStatement(this.vendor); 459 ret.sqlstatementtype = gnewsqlstatementtype; 460 break; 461 } 462 case sstsavepoint: { 463 ret = new TUnknownSqlStatement(this.vendor); 464 ret.sqlstatementtype = gnewsqlstatementtype; 465 break; 466 } 467 case sstRevoke: { 468 ret = new TUnknownSqlStatement(this.vendor); 469 ret.sqlstatementtype = gnewsqlstatementtype; 470 break; 471 } 472 case sstcreatetable: { 473 ret = new TCreateTableSqlStatement(this.vendor); 474 break; 475 } 476 case sstcreateview: { 477 ret = new TCreateViewSqlStatement(this.vendor); 478 break; 479 } 480 case sstcreateindex: { 481 ret = new TCreateIndexSqlStatement(this.vendor); 482 break; 483 } 484 case sstcreatedatabase: { 485 ret = new TCreateDatabaseSqlStatement(this.vendor); 486 break; 487 } 488 case sstdroptable: { 489 ret = new TDropTableSqlStatement(this.vendor); 490 break; 491 } 492 case sstdropview: { 493 ret = new TDropViewSqlStatement(this.vendor); 494 break; 495 } 496 case sstdropindex: { 497 ret = new TDropIndexSqlStatement(this.vendor); 498 break; 499 } 500 case sstaltertable: { 501 ret = new TAlterTableStatement(this.vendor); 502 break; 503 } 504 case sstaltersession: { 505 ret = new TAlterSessionStatement(this.vendor); 506 break; 507 } 508 case sstdb2set: { 509 ret = new TDb2SetVariableStmt(this.vendor); 510 break; 511 } 512 case sstdb2setschema: { 513 ret = new TSetDatabaseObjectStmt(this.vendor); 514 break; 515 } 516 case sstdb2call: { 517 ret = new TDb2CallStmt(this.vendor); 518 break; 519 } 520 case sstdb2declarecursor: { 521 ret = new TDb2DeclareCursorStatement(this.vendor); 522 break; 523 } 524 case sstcreateprocedure: { 525 ret = new TCreateProcedureStmt(this.vendor); 526 break; 527 } 528 case sstcreatefunction: { 529 ret = new TCreateFunctionStmt(this.vendor); 530 break; 531 } 532 case sstdb2createtrigger: { 533 ret = new TCreateTriggerStmt(this.vendor); 534 break; 535 } 536 case sstdb2return: { 537 ret = new TDb2ReturnStmt(this.vendor); 538 break; 539 } 540 case sstdb2refreshtable: 541 case sstdb2connect: 542 case sstdb2terminate: 543 case sstdb2execute: { 544 ret = new TDb2DummyStmt(this.vendor); 545 break; 546 } 547 case sstdb2createalias: { 548 ret = new TCreateAliasStmt(this.vendor); 549 break; 550 } 551 case sstcreateauditpolicy: 552 ret = new TCreateAuditPolicyStmt(this.vendor); 553 break; 554 case sstdb2comment: 555 ret = new TCommentOnSqlStmt(this.vendor); 556 break; 557 case sstdb2createvariable: 558 ret = new TCreateVariableStmt(this.vendor); 559 break; 560 case sstcreaterole: 561 ret = new TCreateRoleStmt(this.vendor); 562 break; 563 case sstcreateTablespace: 564 ret = new TCreateTablespaceStmt(this.vendor); 565 break; 566 case sstRunStats: 567 ret = new TRunStats(this.vendor); 568 break; 569 case ssttruncatetable: { 570 ret = new TTruncateStatement(this.vendor); 571 break; 572 } 573 case sstcreatesynonym: 574 ret = new TCreateSynonymStmt(this.vendor); 575 break; 576 default: { 577 ret = new TUnknownSqlStatement(this.vendor); 578 ret.sqlstatementtype = gnewsqlstatementtype; 579 break; 580 } 581 } 582 583 return ret; 584 } 585}