001package gudusoft.gsqlparser.sqlcmds; 002 003import gudusoft.gsqlparser.*; 004import gudusoft.gsqlparser.stmt.*; 005import gudusoft.gsqlparser.stmt.bigquery.TCreateModelSqlStatement; 006import gudusoft.gsqlparser.stmt.bigquery.TExportDataStmt; 007import gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare; 008 009/** 010 * BigQuery SQL command resolver. 011 * Contains all BigQuery-specific SQL command recognition logic. 012 * 013 * @since 3.1.0.9 014 */ 015public class TSqlCmdsBigquery extends AbstractSqlCmds { 016 017 // Temporary field for statement type during issql processing 018 private ESqlStatementType gnewsqlstatementtype = ESqlStatementType.sstinvalid; 019 020 public TSqlCmdsBigquery() { 021 super(EDbVendor.dbvbigquery); 022 } 023 024 @Override 025 protected String getToken1Str(int token1) { 026 // Handle BigQuery-specific reserved words (token codes > TBaseType.rrw_abort) 027 switch (token1) { 028 case TBaseType.rrw_bigquery_export: 029 return "export"; 030 default: 031 return null; 032 } 033 } 034 035 @Override 036 protected void initializeCommands() { 037 // BigQuery commands must be sorted alphabetically by token1 038 addCmd(TBaseType.rrw_alter, "bi_capacity", ESqlStatementType.sstAlterBiCapacity); 039 addCmd(TBaseType.rrw_alter, "capacity", ESqlStatementType.sstAlterCapacity); 040 addCmd(TBaseType.rrw_alter, "connection", ESqlStatementType.sstAlterConnection); 041 addCmd(TBaseType.rrw_alter, "data_policy", ESqlStatementType.sstAlterDataPolicy); 042 addCmd(TBaseType.rrw_alter, "materialized", "view", ESqlStatementType.sstAlterMaterializedView); 043 addCmd(TBaseType.rrw_alter, "model", ESqlStatementType.sstAlterModel); 044 addCmd(TBaseType.rrw_alter, "organization", ESqlStatementType.sstAlterOrganization); 045 addCmd(TBaseType.rrw_alter, "project", ESqlStatementType.sstAlterProject); 046 addCmd(TBaseType.rrw_alter, "reservation", ESqlStatementType.sstAlterReservation); 047 addCmd(TBaseType.rrw_alter, "schema", ESqlStatementType.sstAlterSchema); 048 addCmd(TBaseType.rrw_alter, "vector", "index", ESqlStatementType.sstAlterVectorIndex); 049 addCmd(TBaseType.rrw_alter, "view", ESqlStatementType.sstalterview); 050 addCmd(TBaseType.rrw_alter, "table", ESqlStatementType.sstaltertable); 051 052 addCmd(TBaseType.rrw_begin, ESqlStatementType.sstBegin); 053 addCmd(TBaseType.rrw_begin, "transaction", ESqlStatementType.sstbegintran); 054 055 addCmd(TBaseType.rrw_call, ESqlStatementType.sstcall); 056 addCmd(TBaseType.rrw_case, ESqlStatementType.sst_casestmt); 057 addCmd(TBaseType.rrw_commit, ESqlStatementType.sstcommit); 058 addCmd(TBaseType.rrw_commit, "transaction", ESqlStatementType.sstcommit); 059 060 // CREATE commands - longer patterns BEFORE shorter ones 061 addCmd(TBaseType.rrw_create, "or", "replace", "external", "table", ESqlStatementType.sstcreatetable); 062 addCmd(TBaseType.rrw_create, "or", "replace", "temporary", "table", ESqlStatementType.sstcreatetable); 063 addCmd(TBaseType.rrw_create, "or", "replace", "materialized", "view", ESqlStatementType.sstcreatematerializedview); 064 addCmd(TBaseType.rrw_create, "or", "replace", "temp", "aggregate", ESqlStatementType.sstcreatefunction); 065 addCmd(TBaseType.rrw_create, "or", "replace", "temporary", "aggregate", ESqlStatementType.sstcreatefunction); 066 addCmd(TBaseType.rrw_create, "or", "replace", "aggregate", "function", ESqlStatementType.sstcreatefunction); 067 addCmd(TBaseType.rrw_create, "or", "replace", "table", "function", ESqlStatementType.sstcreatefunction); 068 addCmd(TBaseType.rrw_create, "or", "replace", "temporary", "function", ESqlStatementType.sstcreatefunction); 069 addCmd(TBaseType.rrw_create, "or", "replace", "temp", "function", ESqlStatementType.sstcreatefunction); 070 addCmd(TBaseType.rrw_create, "or", "replace", "temp", "table", ESqlStatementType.sstcreatetable); 071 addCmd(TBaseType.rrw_create, "or", "replace", "function", ESqlStatementType.sstcreatefunction); 072 addCmd(TBaseType.rrw_create, "or", "replace", "procedure", ESqlStatementType.sstcreateprocedure); 073 addCmd(TBaseType.rrw_create, "or", "replace", "row", "access", ESqlStatementType.sstCreateRowAccessPolicy); 074 addCmd(TBaseType.rrw_create, "or", "replace", "table", ESqlStatementType.sstcreatetable); 075 addCmd(TBaseType.rrw_create, "or", "replace", "view", ESqlStatementType.sstcreateview); 076 addCmd(TBaseType.rrw_create, "or", "replace", "model", ESqlStatementType.sstcreatemodel); 077 addCmd(TBaseType.rrw_create, "temp", "aggregate", "function", ESqlStatementType.sstcreatefunction); 078 addCmd(TBaseType.rrw_create, "temporary", "aggregate", "function", ESqlStatementType.sstcreatefunction); 079 addCmd(TBaseType.rrw_create, "aggregate", "function", ESqlStatementType.sstcreatefunction); 080 addCmd(TBaseType.rrw_create, "assignment", ESqlStatementType.sstCreateAssignment); 081 addCmd(TBaseType.rrw_create, "or", "replace", "connection", ESqlStatementType.sstCreateConnection); 082 addCmd(TBaseType.rrw_create, "capacity", ESqlStatementType.sstCreateCapacity); 083 addCmd(TBaseType.rrw_create, "connection", ESqlStatementType.sstCreateConnection); 084 addCmd(TBaseType.rrw_create, "data_policy", ESqlStatementType.sstCreateDataPolicy); 085 addCmd(TBaseType.rrw_create, "external", "schema", ESqlStatementType.sstcreateschema); 086 addCmd(TBaseType.rrw_create, "external", "table", ESqlStatementType.sstcreatetable); 087 addCmd(TBaseType.rrw_create, "materialized", "view", ESqlStatementType.sstcreatematerializedview); 088 addCmd(TBaseType.rrw_create, "reservation", ESqlStatementType.sstCreateReservation); 089 addCmd(TBaseType.rrw_create, "row", "access", "policy", ESqlStatementType.sstCreateRowAccessPolicy); 090 addCmd(TBaseType.rrw_create, "schema", ESqlStatementType.sstcreateschema); 091 addCmd(TBaseType.rrw_create, "search", "index", ESqlStatementType.sstcreateindex); 092 addCmd(TBaseType.rrw_create, "snapshot", "table", ESqlStatementType.sstcreatetable); 093 addCmd(TBaseType.rrw_create, "table", "function", ESqlStatementType.sstcreatefunction); 094 addCmd(TBaseType.rrw_create, "temporary", "function", ESqlStatementType.sstcreatefunction); 095 addCmd(TBaseType.rrw_create, "temporary", "table", ESqlStatementType.sstcreatetable); 096 addCmd(TBaseType.rrw_create, "temp", "function", ESqlStatementType.sstcreatefunction); 097 addCmd(TBaseType.rrw_create, "temp", "table", ESqlStatementType.sstcreatetable); 098 addCmd(TBaseType.rrw_create, "vector", "index", ESqlStatementType.sstcreateindex); 099 addCmd(TBaseType.rrw_create, "function", ESqlStatementType.sstcreatefunction); 100 addCmd(TBaseType.rrw_create, "model", ESqlStatementType.sstcreatemodel); 101 addCmd(TBaseType.rrw_create, "procedure", ESqlStatementType.sstcreateprocedure); 102 addCmd(TBaseType.rrw_create, "table", ESqlStatementType.sstcreatetable); 103 addCmd(TBaseType.rrw_create, "view", ESqlStatementType.sstcreateview); 104 addCmd(TBaseType.rrw_declare, ESqlStatementType.sstBigQueryDeclare); 105 addCmd(TBaseType.rrw_delete, ESqlStatementType.sstdelete); 106 107 // DROP commands - longer patterns BEFORE shorter ones 108 addCmd(TBaseType.rrw_drop, "all", "row", "access", "policies", ESqlStatementType.sstDropRowAccessPolicy); 109 addCmd(TBaseType.rrw_drop, "row", "access", "policy", ESqlStatementType.sstDropRowAccessPolicy); 110 addCmd(TBaseType.rrw_drop, "search", "index", ESqlStatementType.sstDropSearchIndex); 111 addCmd(TBaseType.rrw_drop, "vector", "index", ESqlStatementType.sstDropVectorIndex); 112 addCmd(TBaseType.rrw_drop, "table", "function", ESqlStatementType.sstDropTableFunction); 113 addCmd(TBaseType.rrw_drop, "snapshot", "table", ESqlStatementType.sstDropSnapshotTable); 114 addCmd(TBaseType.rrw_drop, "materialized", "view", ESqlStatementType.sstDropMaterializedView); 115 addCmd(TBaseType.rrw_drop, "external", "table", ESqlStatementType.sstdroptable); 116 addCmd(TBaseType.rrw_drop, "assignment", ESqlStatementType.sstDropAssignment); 117 addCmd(TBaseType.rrw_drop, "capacity", ESqlStatementType.sstDropCapacity); 118 addCmd(TBaseType.rrw_drop, "connection", ESqlStatementType.sstDropConnection); 119 addCmd(TBaseType.rrw_drop, "data_policy", ESqlStatementType.sstDropDataPolicy); 120 addCmd(TBaseType.rrw_drop, "function", ESqlStatementType.sstdropfunction); 121 addCmd(TBaseType.rrw_drop, "model", ESqlStatementType.sstdropmodel); 122 addCmd(TBaseType.rrw_drop, "procedure", ESqlStatementType.sstdropprocedure); 123 addCmd(TBaseType.rrw_drop, "reservation", ESqlStatementType.sstDropReservation); 124 addCmd(TBaseType.rrw_drop, "schema", ESqlStatementType.sstdropschema); 125 addCmd(TBaseType.rrw_drop, "table", ESqlStatementType.sstdroptable); 126 addCmd(TBaseType.rrw_drop, "view", ESqlStatementType.sstdropview); 127 128 addCmd(TBaseType.rrw_execute, "immediate", ESqlStatementType.sstExecute); 129 130 addCmd(TBaseType.rrw_bigquery_export, "data", ESqlStatementType.sstBigQueryExportData); 131 addCmd(TBaseType.rrw_bigquery_export, "model", ESqlStatementType.sstBigQueryExportModel); 132 addCmd(TBaseType.rrw_for, ESqlStatementType.sstForStmt); 133 addCmd(TBaseType.rrw_grant, ESqlStatementType.sstGrant); 134 addCmd(TBaseType.rrw_if, ESqlStatementType.sst_ifstmt); 135 addCmd(TBaseType.rrw_insert, ESqlStatementType.sstinsert); 136 addCmd(TBaseType.rrw_load, "data", ESqlStatementType.sstLoadData); 137 addCmd(TBaseType.rrw_loop, ESqlStatementType.sst_loopstmt); 138 addCmd(TBaseType.rrw_merge, ESqlStatementType.sstmerge); 139 addCmd(TBaseType.rrw_repeat, ESqlStatementType.sstRepeat); 140 addCmd(TBaseType.rrw_revoke, ESqlStatementType.sstRevoke); 141 addCmd(TBaseType.rrw_rollback, ESqlStatementType.sstrollback); 142 addCmd(TBaseType.rrw_rollback, "transaction", ESqlStatementType.sstrollback); 143 addCmd(TBaseType.rrw_select, ESqlStatementType.sstselect); 144 addCmd(TBaseType.rrw_set, ESqlStatementType.sstset); 145 addCmd(TBaseType.rrw_truncate, ESqlStatementType.sstTruncate); 146 addCmd(TBaseType.rrw_update, ESqlStatementType.sstupdate); 147 addCmd(TBaseType.rrw_while, ESqlStatementType.sstWhilestmt); 148 } 149 150 @Override 151 public TCustomSqlStatement issql(TSourceToken pcst, EFindSqlStateType pstate, TCustomSqlStatement psqlstatement) { 152 TCustomSqlStatement ret = null; 153 154 gnewsqlstatementtype = ESqlStatementType.sstinvalid; 155 156 if ((pcst.tokencode == TBaseType.cmtdoublehyphen) 157 || (pcst.tokencode == TBaseType.cmtslashstar) 158 || (pcst.tokencode == TBaseType.lexspace) 159 || (pcst.tokencode == TBaseType.lexnewline) 160 || (pcst.tokentype == ETokenType.ttsemicolon)) { 161 return null; 162 } 163 164 int lcpos = pcst.posinlist; 165 TSourceTokenList lcsourcetokenlist = pcst.container; 166 TCustomSqlStatement lccurrentsqlstatement = psqlstatement; 167 168 //subquery after semicolon or at first line 169 if ((pstate == EFindSqlStateType.stnormal) && (pcst.tokentype == ETokenType.ttleftparenthesis)) // ( 170 { 171 int k = lcsourcetokenlist.solidtokenafterpos(lcpos, TBaseType.rrw_select, 1, "("); 172 if (k > 0) { 173 ret = new TSelectSqlStatement(this.vendor); 174 } 175 176 return ret; 177 } 178 179 //cte 180 if ((pstate == EFindSqlStateType.stnormal) && (pcst.tokencode == TBaseType.rrw_with)) { 181 ret = findcte(pcst); 182 if ((ret != null)) return ret; 183 } 184 185 gnewsqlstatementtype = getStatementTypeForToken(pcst); 186 187 TSourceToken lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 188 switch (gnewsqlstatementtype) { // 189 case sstinvalid: { 190 ret = null; 191 192 if (pstate == EFindSqlStateType.stnormal) { 193 if (pcst.tokencode == TBaseType.rrw_begin) { 194 195 ret = new TCommonBlock(this.vendor); 196 gnewsqlstatementtype = ret.sqlstatementtype; 197 } 198 199 } 200 201 // Handle UNDROP SCHEMA statement 202 if (ret == null && pstate == EFindSqlStateType.stnormal 203 && pcst.toString().equalsIgnoreCase("UNDROP")) { 204 ret = new TUnknownSqlStatement(this.vendor); 205 ret.sqlstatementtype = ESqlStatementType.sstUndropSchema; 206 gnewsqlstatementtype = ESqlStatementType.sstUndropSchema; 207 } 208 209 // Handle ASSERT statement 210 if (ret == null && pstate == EFindSqlStateType.stnormal 211 && pcst.toString().equalsIgnoreCase("ASSERT")) { 212 ret = new TUnknownSqlStatement(this.vendor); 213 gnewsqlstatementtype = ESqlStatementType.sstBigQueryAssert; 214 } 215 216 // Handle RAISE statement 217 if (ret == null && pstate == EFindSqlStateType.stnormal 218 && pcst.toString().equalsIgnoreCase("RAISE")) { 219 ret = new TUnknownSqlStatement(this.vendor); 220 ret.sqlstatementtype = ESqlStatementType.sst_raisestmt; 221 gnewsqlstatementtype = ESqlStatementType.sst_raisestmt; 222 } 223 224 // Handle standalone FROM for pipe syntax: FROM table |> WHERE ... 225 if (ret == null && pstate == EFindSqlStateType.stnormal 226 && pcst.tokencode == TBaseType.rrw_from) { 227 ret = new TUnknownSqlStatement(this.vendor); 228 ret.sqlstatementtype = ESqlStatementType.sstselect; 229 gnewsqlstatementtype = ESqlStatementType.sstselect; 230 } 231 232 // Handle labeled loops: label: LOOP ... END LOOP label 233 if (ret == null && pcst.tokencode == TBaseType.ident) { 234 TSourceToken nextToken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 235 if (nextToken != null && nextToken.tokencode == ':') { 236 TSourceToken afterColon = lcsourcetokenlist.nextsolidtoken(nextToken.posinlist, 1, false); 237 if (afterColon != null && afterColon.tokencode == TBaseType.rrw_loop) { 238 ret = new TLoopStmt(this.vendor); 239 gnewsqlstatementtype = ESqlStatementType.sst_loopstmt; 240 } else if (afterColon != null && afterColon.tokencode == TBaseType.rrw_begin) { 241 ret = new TCommonBlock(this.vendor); 242 gnewsqlstatementtype = ret.sqlstatementtype; 243 } else if (afterColon != null && afterColon.tokencode == TBaseType.rrw_while) { 244 ret = new TWhileStmt(this.vendor); 245 gnewsqlstatementtype = ESqlStatementType.sstWhilestmt; 246 } else if (afterColon != null && afterColon.tokencode == TBaseType.rrw_for) { 247 ret = new TForStmt(this.vendor); 248 gnewsqlstatementtype = ESqlStatementType.sstForStmt; 249 } else if (afterColon != null && afterColon.tokencode == TBaseType.rrw_repeat) { 250 ret = new TRepeatStmt(this.vendor); 251 gnewsqlstatementtype = ESqlStatementType.sstRepeat; 252 } 253 } 254 } 255 break; 256 } 257 case sstselect: { 258 boolean lcisnewsql = true; 259 260 if (pstate != EFindSqlStateType.stnormal) { 261 // lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 262 if ((lcprevsolidtoken != null)) { 263 if (lcprevsolidtoken.tokentype == ETokenType.ttleftparenthesis) 264 lcisnewsql = false; //subqery 265 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_union) 266 lcisnewsql = false; 267 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_intersect) 268 lcisnewsql = false; 269 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_minus) 270 lcisnewsql = false; 271 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_except) 272 lcisnewsql = false; 273 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_return) 274 lcisnewsql = false; 275 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_as) { 276 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetable) 277 lcisnewsql = false; 278 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateview) 279 lcisnewsql = false; 280 } 281 282 if (lcisnewsql && (lcprevsolidtoken.tokencode == TBaseType.rrw_all)) { 283 TSourceToken lcpprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcprevsolidtoken.posinlist); 284 if ((lcpprevsolidtoken != null)) { 285 if (lcpprevsolidtoken.tokencode == TBaseType.rrw_union) 286 lcisnewsql = false; 287 } 288 } 289 290 } 291 292 293 if ((lccurrentsqlstatement != null)) { 294 if (lccurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstinsert) 295 lcisnewsql = false; 296 } 297 298 } 299 300 if (lcisnewsql) 301 ret = new TSelectSqlStatement(this.vendor); 302 303 break; 304 } 305 case sstinsert: { 306 boolean lcisnewsql = true; 307 if (pstate != EFindSqlStateType.stnormal) { 308 if ((lccurrentsqlstatement != null)) { 309 310 } 311 } 312 313 if (lcisnewsql) 314 ret = new TInsertSqlStatement(this.vendor); 315 316 break; 317 } 318 case sstupdate: { 319 boolean lcisnewsql = true; 320 if (pstate != EFindSqlStateType.stnormal) { 321 lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 322 if ((lcprevsolidtoken != null)) { // 323 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 324 lcisnewsql = false; 325 else if (lcprevsolidtoken.tokencode == TBaseType.rrw_for) 326 lcisnewsql = false; 327 } 328 329 TSourceToken lcnextsolidtoken = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 330 if ((lcnextsolidtoken != null)) { 331 if (lcnextsolidtoken.tokentype == ETokenType.ttleftparenthesis) { 332 int k = lcsourcetokenlist.solidtokenafterpos(lcnextsolidtoken.posinlist, TBaseType.rrw_select, 1, "("); 333 if (k == 0) lcisnewsql = false; 334 } 335 } 336 337 338 if ((lccurrentsqlstatement != null)) { 339 } 340 } 341 342 if (lcisnewsql) { 343 ret = new TUpdateSqlStatement(this.vendor); 344 ret.dummytag = 1; // means set clause in update is not found yet, used to seperate set clause from set statement 345 } 346 break; 347 } 348 case sstdelete: { 349 boolean lcisnewsql = true; 350 351 if (pstate != EFindSqlStateType.stnormal) { 352 lcprevsolidtoken = lcsourcetokenlist.solidtokenbefore(lcpos); 353 if ((lcprevsolidtoken != null)) { 354 if (lcprevsolidtoken.tokencode == TBaseType.rrw_on) 355 lcisnewsql = false; 356 } 357 358 if ((lccurrentsqlstatement != null)) { 359 } 360 } 361 362 if (lcisnewsql) 363 ret = new TDeleteSqlStatement(this.vendor); 364 365 break; 366 } 367 case sstmerge: { 368 ret = new TMergeSqlStatement(this.vendor); 369 ret.sqlstatementtype = gnewsqlstatementtype; 370 break; 371 } 372 case sstcreatetable: { 373 ret = new TCreateTableSqlStatement(this.vendor); 374 break; 375 } 376 case sstcreateview: { 377 ret = new TCreateViewSqlStatement(this.vendor); 378 break; 379 } 380 case sstaltertable: { 381 ret = new TAlterTableStatement(this.vendor); 382 break; 383 } 384 case sstalterview: { 385 ret = new TAlterViewStatement(this.vendor); 386 break; 387 } 388 case sstdroptable: { 389 ret = new TDropTableSqlStatement(this.vendor); 390 break; 391 } 392 case sstdropview: { 393 ret = new TDropViewSqlStatement(this.vendor); 394 break; 395 } 396 case sstcreatefunction: { 397 ret = new TCreateFunctionStmt(this.vendor); 398 break; 399 } 400 case sstcreateprocedure: { 401 ret = new TCreateProcedureStmt(this.vendor); 402 break; 403 } 404 case sstBigQueryDeclare: 405 ret = new TMssqlDeclare(this.vendor); 406 break; 407 case sstTruncate: { 408 ret = new TTruncateStatement(this.vendor); 409 break; 410 } 411 case sstset: { 412 boolean lcisnewsql = true; 413 if (pstate != EFindSqlStateType.stnormal) { 414 if (TBaseType.assigned(lccurrentsqlstatement)) { 415 lcisnewsql = false; 416 } 417 } 418 419 if (lcisnewsql) { 420 ret = new TSetStmt(this.vendor); 421 } 422 break; 423 } 424 case sstcreatematerializedview: { 425 ret = new TCreateMaterializedSqlStatement(this.vendor); 426 break; 427 } 428 case sstdropprocedure: { 429 ret = new TDropProcedureStmt(this.vendor); 430 break; 431 } 432 case sstdropfunction: { 433 ret = new TDropFunctionStmt(this.vendor); 434 break; 435 } 436 case sstDropMaterializedView: 437 ret = new TDropMaterializedViewStmt(this.vendor); 438 break; 439 case sstcall: 440 ret = new TCallStatement(this.vendor); 441 break; 442 case sstBigQueryExportData: 443 ret = new TExportDataStmt(this.vendor); 444 break; 445 case sstBigQueryExportModel: 446 ret = new TUnknownSqlStatement(this.vendor); 447 ret.sqlstatementtype = gnewsqlstatementtype; 448 break; 449 case sstcreatemodel: 450 ret = new TCreateModelSqlStatement(this.vendor); 451 break; 452 case sstdropmodel: 453 ret = new TDropStmt(this.vendor); 454 ret.sqlstatementtype = gnewsqlstatementtype; 455 break; 456 case sstBegin: { 457 // Determine if BEGIN starts a block or a transaction. 458 // BEGIN TRANSACTION → treat as transaction (not a block) 459 // BEGIN; or bare BEGIN → treat as BEGIN TRANSACTION 460 // BEGIN <anything else> → BEGIN...END block 461 TSourceToken nextSolid = lcsourcetokenlist.nextsolidtoken(lcpos, 1, false); 462 if (nextSolid != null && nextSolid.toString().equalsIgnoreCase("TRANSACTION")) { 463 // BEGIN TRANSACTION: treat as transaction statement 464 ret = new TUnknownSqlStatement(this.vendor); 465 ret.sqlstatementtype = ESqlStatementType.sstbegintran; 466 gnewsqlstatementtype = ESqlStatementType.sstbegintran; 467 pcst.tokencode = TBaseType.rrw_bigquery_begin_transaction; 468 } else if (nextSolid == null || nextSolid.tokencode == ';') { 469 // Bare BEGIN or BEGIN; → treat as BEGIN TRANSACTION 470 ret = new TUnknownSqlStatement(this.vendor); 471 ret.sqlstatementtype = ESqlStatementType.sstbegintran; 472 gnewsqlstatementtype = ESqlStatementType.sstbegintran; 473 pcst.tokencode = TBaseType.rrw_bigquery_begin_transaction; 474 } else { 475 // BEGIN followed by something else → BEGIN...END block 476 ret = new TCommonBlock(this.vendor); 477 gnewsqlstatementtype = ret.sqlstatementtype; 478 } 479 480 break; 481 } 482 case sstbegintran: { 483 ret = new TUnknownSqlStatement(this.vendor); 484 ret.sqlstatementtype = gnewsqlstatementtype; 485 if (pcst.tokencode == TBaseType.rrw_begin) { 486 pcst.tokencode = TBaseType.rrw_bigquery_begin_transaction; 487 } 488 489 break; 490 } 491 case sstExecute: { 492 ret = new TExecImmeStmt(this.vendor); 493 break; 494 } 495 case sst_ifstmt: 496 ret = new TIfStmt(this.vendor); 497 break; 498 case sst_loopstmt: 499 ret = new TLoopStmt(this.vendor); 500 break; 501 case sstRepeat: 502 ret = new TRepeatStmt(this.vendor); 503 break; 504 case sstWhilestmt: 505 ret = new TWhileStmt(this.vendor); 506 break; 507 case sstForStmt: 508 ret = new TForStmt(this.vendor); 509 break; 510 case sst_casestmt: 511 ret = new TCaseStmt(this.vendor); 512 break; 513 case sstcreateschema: 514 ret = new TUnknownSqlStatement(this.vendor); 515 ret.sqlstatementtype = gnewsqlstatementtype; 516 break; 517 case sstAlterSchema: 518 ret = new TUnknownSqlStatement(this.vendor); 519 ret.sqlstatementtype = gnewsqlstatementtype; 520 break; 521 case sstAlterBiCapacity: 522 case sstAlterCapacity: 523 case sstAlterConnection: 524 case sstAlterDataPolicy: 525 case sstAlterMaterializedView: 526 case sstAlterModel: 527 case sstAlterOrganization: 528 case sstAlterProject: 529 case sstAlterReservation: 530 case sstAlterVectorIndex: 531 ret = new TUnknownSqlStatement(this.vendor); 532 ret.sqlstatementtype = gnewsqlstatementtype; 533 break; 534 case sstcreateindex: 535 ret = new TUnknownSqlStatement(this.vendor); 536 ret.sqlstatementtype = gnewsqlstatementtype; 537 break; 538 case sstdropindex: 539 case sstDropSearchIndex: 540 case sstDropVectorIndex: 541 ret = new TUnknownSqlStatement(this.vendor); 542 ret.sqlstatementtype = gnewsqlstatementtype; 543 break; 544 case sstCreateRowAccessPolicy: 545 ret = new TUnknownSqlStatement(this.vendor); 546 ret.sqlstatementtype = gnewsqlstatementtype; 547 break; 548 case sstLoadData: 549 ret = new TUnknownSqlStatement(this.vendor); 550 ret.sqlstatementtype = gnewsqlstatementtype; 551 break; 552 case sstGrant: 553 ret = new TUnknownSqlStatement(this.vendor); 554 ret.sqlstatementtype = gnewsqlstatementtype; 555 break; 556 case sstRevoke: 557 ret = new TUnknownSqlStatement(this.vendor); 558 ret.sqlstatementtype = gnewsqlstatementtype; 559 break; 560 case sstBigQueryAssert: 561 case sst_raisestmt: 562 ret = new TUnknownSqlStatement(this.vendor); 563 ret.sqlstatementtype = gnewsqlstatementtype; 564 break; 565 case sstcommit: 566 ret = new TCommitStmt(this.vendor); 567 break; 568 case sstrollback: 569 ret = new TRollbackStmt(this.vendor); 570 break; 571 case sstCreateConnection: 572 case sstCreateCapacity: 573 case sstCreateDataPolicy: 574 case sstCreateReservation: 575 case sstCreateAssignment: 576 ret = new TUnknownSqlStatement(this.vendor); 577 ret.sqlstatementtype = gnewsqlstatementtype; 578 break; 579 case sstDropConnection: 580 ret = new TDropStmt(this.vendor); 581 ret.sqlstatementtype = gnewsqlstatementtype; 582 break; 583 case sstDropDataPolicy: 584 ret = new TUnknownSqlStatement(this.vendor); 585 ret.sqlstatementtype = gnewsqlstatementtype; 586 break; 587 case sstDropAssignment: 588 ret = new TDropStmt(this.vendor); 589 break; 590 case sstDropCapacity: 591 ret = new TDropStmt(this.vendor); 592 break; 593 case sstdropschema: 594 ret = new TDropSchemaSqlStatement(this.vendor); 595 break; 596 case sstDropReservation: 597 ret = new TDropStmt(this.vendor); 598 break; 599 case sstDropRowAccessPolicy: 600 ret = new TDropStmt(this.vendor); 601 break; 602 case sstDropSnapshotTable: 603 ret = new TDropStmt(this.vendor); 604 break; 605 case sstDropTableFunction: 606 ret = new TDropStmt(this.vendor); 607 break; 608 case sstUndropSchema: 609 ret = new TUnknownSqlStatement(this.vendor); 610 ret.sqlstatementtype = gnewsqlstatementtype; 611 break; 612 default: { 613 ret = new TUnknownSqlStatement(this.vendor); 614 ret.sqlstatementtype = gnewsqlstatementtype; 615 break; 616 } 617 } // case 618 619 return ret; 620 } 621}