001package gudusoft.gsqlparser.pp.stmtformatter; 002import java.util.ArrayList; 003import java.util.Arrays; 004import java.util.Collections; 005import java.util.List; 006import java.util.StringTokenizer; 007import java.util.regex.Matcher; 008import java.util.regex.Pattern; 009 010import gudusoft.gsqlparser.EDbVendor; 011import gudusoft.gsqlparser.pp.para.GFmtOpt; 012import gudusoft.gsqlparser.pp.para.GFmtOptFactory; 013 014public class SQLion { 015 016 private String commonFunctions; 017 private String commonFunctions1; 018 private String commonFunctions2; 019 private String commonFunctions3; 020 private String commonFunctions4; 021 private String commonFunctions5; 022 private String commonFunctions6; 023 private String commonFunctions7; 024 private String commonFunctions8; 025 private String commonFunctions9; 026 private String commonFunctions10; 027 private String commonFunctions11; 028 private String commonFunctions12; 029 private String commonFunctions13; 030 private String commonFunctions14; 031 private String commonFunctions15; 032 private String commonFunctions16; 033 private String commonFunctions17; 034 private String commonFunctions18; 035 private String commonFunctions19; 036 private String commonFunctions20; 037 private String commonFunctions21; 038 private String commonFunctions22; 039 private String commonFunctions23; 040 private String commonFunctions24; 041 private String commonFunctions25; 042 private String commonFunctions26; 043 private String commonFunctions27; 044 private String commonFunctions28; 045 private String commonFunctions29; 046 private String commonFunctions30; 047 048 private String TeradataFunctions; 049 private String TeradataFunctions1; 050 private String TeradataFunctions2; 051 private String TeradataFunctions3; 052 private String TeradataFunctions4; 053 private String TeradataFunctions5; 054 private String TeradataFunctions6; 055 private String TeradataFunctions7; 056 private String TeradataFunctions8; 057 private String TeradataFunctions9; 058 private String TeradataFunctions10; 059 private String TeradataFunctions11; 060 private String TeradataFunctions12; 061 private String TeradataFunctions13; 062 private String TeradataFunctions14; 063 private String TeradataFunctions15; 064 private String TeradataFunctions16; 065 private String TeradataFunctions17; 066 private String TeradataFunctions18; 067 private String TeradataFunctions19; 068 private String TeradataFunctions20; 069 private String TeradataFunctions21; 070 private String TeradataFunctions22; 071 private String TeradataFunctions23; 072 private String TeradataFunctions24; 073 private String TeradataFunctions25; 074 private String TeradataFunctions26; 075 private String TeradataFunctions27; 076 private String TeradataFunctions28; 077 private String TeradataFunctions29; 078 private String TeradataFunctions30; 079 private String TeradataFunctions31; 080 private String TeradataFunctions32; 081 private String TeradataFunctions33; 082 private String TeradataFunctions34; 083 private String TeradataFunctions35; 084 private String TeradataFunctions36; 085 private String TeradataFunctions37; 086 private String TeradataFunctions38; 087 private String TeradataFunctions39; 088 private String TeradataFunctions40; 089 private String TeradataFunctions41; 090 private String TeradataFunctions42; 091 private String TeradataFunctions43; 092 private String TeradataFunctions44; 093 private String TeradataFunctions45; 094 private String TeradataFunctions46; 095 096 // Char variables 097 private String c_numberOfSpace_1; 098 private String c_numberOfSpace_n; 099 private String c_numberOfSpace_m1; 100 101 // String variables 102 private String c_functionStr1; 103 private String c_functionStr2; 104 private String c_functionStr3; 105 private String c_sqlplusStr1; 106 private String c_sqlplusStr2; 107 private String c_datatypeStr; 108 private String c_joinStr; 109 private String c_fromWhereMoreKeywordsStr; 110 private String c_sqlServerSPRelatedSqlStr1; 111 private String c_sqlServerSPRelatedSqlStr2; 112 private String c_noSpacesAroundBracket; 113 private String c_oneSpaceInsideBracket; 114 private String c_oneSpaceOutsideBracket; 115 private String c_oneSpaceAroundBracket; 116 private String c_noSpacesAroundComma; 117 private String c_oneSpaceAfterComma; 118 private String c_oneSpaceBeforeComma; 119 private String c_oneSpaceAroundComma; 120 private String c_noSpacesAroundEqual; 121 private String c_oneSpaceAroundEqual; 122 private String c_unchangedSpaceInsideBracket; 123 private String c_unchangedSpaceComma; 124 private String c_unchangedEqualComma; 125 private String align_left; 126 private String align_right; 127 private String boolean_yes; 128 private String boolean_no; 129 private String c_all; 130 private String c_alter_function; 131 private String c_alter_proc; 132 private String c_alter_procedure; 133 private String c_alter_table; 134 private String c_alter_view; 135 private String c_and; 136 private String c_as; 137 private String c_begin; 138 private String c_begin_catch; 139 private String c_begin_tran; 140 private String c_begin_transaction; 141 private String c_begin_try; 142 private String c_between; 143 private String c_by; 144 private String c_case; 145 private String c_cast; 146 private String c_Close; 147 private String c_collect; 148 private String c_commit; 149 private String c_concat; 150 private String c_connect_by; 151 private String c_create; 152 private String c_create_function; 153 private String c_create_proc; 154 private String c_create_procedure; 155 private String c_create_synonym; 156 private String c_cross_apply; 157 private String c_cross_join; 158 private String c_cube; 159 private String c_cursor; 160 private String c_deallocate; 161 private String c_declare; 162 private String c_declare_global_temporary_table; 163 private String c_decode; 164 private String c_del; 165 private String c_delete; 166 private String c_drop_procedure; 167 private String c_drop_table; 168 private String c_else; 169 private String c_elsif; 170 private String c_elseif; 171 private String c_end; 172 private String c_end_catch; 173 private String c_end_tran; 174 private String c_end_transaction; 175 private String c_end_try; 176 private String c_exec; 177 private String c_execute; 178 private String c_except; 179 private String c_exception; 180 private String c_exception_join; 181 private String c_floor; 182 private String c_FIRST; 183 private String c_for_delete; 184 private String c_for_insert; 185 private String c_for_update; 186 private String c_function; 187 private String c_grant_execute; 188 private String c_group_by; 189 private String c_having; 190 private String c_iif; 191 private String c_if; 192 private String c_in; 193 private String c_inner_join; 194 private String c_inout; 195 private String c_ins; 196 private String c_insert; 197 private String c_insert_into; 198 private String c_ins_into; 199 private String c_intersect; 200 private String c_into; 201 private String c_is; 202 private String c_is_distinct_from; 203 private String c_is_not_distinct_from; 204 private String c_like; 205 private String c_next; 206 private String c_not; 207 private String c_not_like; 208 private String c_null; 209 private String c_is_not_null; 210 private String c_is_null; 211 private String c_fetch; 212 private String c_for; 213 private String c_full_inner_join; 214 private String c_full_join; 215 private String c_full_outer_join; 216 private String c_function_header; 217 private String c_from; 218 private String c_go; 219 private String c_left_exception_join; 220 private String c_left_join; 221 private String c_left_outer_join; 222 private String c_limit; 223 private String c_locking; 224 private String c_loop; 225 private String c_minus; 226 private String c_member; 227 private String c_merge; 228 private String c_object; 229 private String c_offset; 230 private String c_on; 231 private String c_open; 232 private String c_openquery; 233 private String c_out; 234 private String c_outer_apply; 235 private String c_outer_join; 236 private String c_or; 237 private String c_order_by; 238 private String c_order_siblings_by; 239 private String c_package; 240 private String c_package_header; 241 private String c_pause; 242 private String c_print; 243 private String c_pro; 244 private String c_procedure; 245 private String c_procedure_header; 246 private String c_prompt; 247 private String c_qualify; 248 private String c_queryno; 249 private String c_raiserror; 250 private String c_record; 251 private String c_rem; 252 private String c_remark; 253 private String c_repeat; 254 private String c_return; 255 private String c_returning; 256 private String c_returns; 257 private String c_right_exception_join; 258 private String c_right_join; 259 private String c_right_outer_join; 260 private String c_rollback_transaction; 261 private String c_rollup; 262 private String c_run; 263 private String c_sel_all; 264 private String c_sel_distinct; 265 private String c_select; 266 private String c_sel; 267 private String c_select_all; 268 private String c_select_distinct; 269 private String c_set; 270 private String c_sort_by; 271 private String c_sql; 272 private String c_start_with; 273 private String c_table; 274 private String c_then; 275 private String c_truncate_table; 276 private String c_type; 277 private String c_union; 278 private String c_union_all; 279 private String c_upd; 280 private String c_update; 281 private String c_values; 282 private String c_vb_string; 283 private String c_when; 284 private String c_when_matched; 285 private String c_when_not_matched; 286 private String c_where; 287 private String c_while; 288 private String c_with; 289 private String c_with_check; 290 private String c_with_execute_as; 291 292 // Regular expression patterns 293 private String regex_patternBn; 294 private String regex_number; 295 private String regex_float; 296 private String regex_collect_stats_on; 297 private String regex_create_or_replace_function; 298 private String regex_create_or_replace_function_mysql; 299 private String regex_create_or_replace_package; 300 private String regex_create_or_replace_package_mysql; 301 private String regex_create_or_replace_procedure; 302 private String regex_create_or_replace_procedure_mysql; 303 private String regex_create_or_replace_view; 304 private String regex_create_or_replace_synonym; 305 private String regex_create_or_replace_table; 306 private String regex_create_global_temporary_table; 307 private String regex_create_set_volatile_table; 308 private String regex_create_set_global_temporary_table; 309 private String regex_create_unique_index; 310 private String regex_create_temporary_table_if_not_exists; 311 private String regex_cursor_is; 312 private String regex_declare_cursor_for; 313 private String regex_declare_cursor_for2; 314 private String regex_declare_global_temporary_table; 315 private String regex_declare_table; 316 private String regex_drop_table_if_not_exists; 317 private String regex_exec; 318 private String regex_locking_table; 319 private String regex_open_cursor_for; 320 private String regex_returns_table; 321 private String regex_select_top_with; 322 private String regex_with_nolock_rowlock_tablock; 323 private String regex_with_execute_as; 324 private String regex_with_cte; 325 private String regex_w; 326 327 // Other variables 328 private String PatternBn; 329 private String patternMatchedString; 330 private short patternMatchedTokenNum; 331 private String br; 332 private String bs; 333 private String bt; 334 private String bu; 335 private int bv; 336 private int bw; 337 338 // Boolean variables 339 private boolean neverExpired; 340 private boolean bq; 341 private boolean bQ1; 342 private boolean bY; 343 private boolean[] IsEndBlock; 344 private boolean[] IsEndCase; 345 private boolean[] IsEndDoubleQuotes; 346 private boolean[] IsEndComment; 347 private boolean[] isEndLineComment; 348 private boolean[] isEndBlockComment; 349 private boolean[] IsEndLiteral; 350 private boolean[] IsEndFrozenZone; 351 private boolean[] IsEndOfCompleteSQL; 352 private boolean[] IsEndOfaSQL; 353 private boolean[] tNbrck; 354 private boolean[] IsEndSELECTList; 355 private boolean[] IsEndJOIN; 356 private boolean[] IsEndJOIN_ON; 357 private boolean[] IsEndFROM; 358 private boolean[] IsEndWHERE; 359 private boolean[] IsEndGROUPBY; 360 private boolean[] IsEndORDERBY; 361 private boolean[] tNbrcs; 362 private boolean[] tNbrInBlock; 363 private boolean[] IsInCase; 364 private boolean[] tNbrInDoubleQuotes; 365 private boolean[] IsInComment; 366 private boolean[] isInlineComment; 367 private boolean[] IsInLiteral; 368 private boolean[] IsInFrozenZone; 369 private boolean[] IsInNonFormatZone; 370 private boolean[] isInBlockComment; 371 private boolean[] tNbrcC; 372 private boolean[] IsInaSQL; 373 private boolean[] IsInSmallSQL; 374 private boolean[] tNbrcF; 375 private boolean[] IsInSELECTList; 376 private boolean[] IsInJOIN; 377 private boolean[] IsInJOIN_ON; 378 private boolean[] IsInFROM; 379 private boolean[] IsInWHERE; 380 private boolean[] IsInGROUPBY; 381 private boolean[] IsInORDERBY; 382 private boolean[] tNbrcN; 383 private boolean[] tNbrKeyword1; 384 private boolean[] tNbrStartBlock; 385 private boolean[] IsStartCase; 386 private boolean[] IsStartDoubleQuotes; 387 private boolean[] IsStartComment; 388 private boolean[] isStartLineComment; 389 private boolean[] isStartBlockComment; 390 private boolean[] IsStartLiteral; 391 private boolean[] IsStartFrozenZone; 392 private boolean[] IsStartOfaSQL; 393 private boolean[] tNbrcY; 394 private boolean[] IsStartSELECTList; 395 private boolean[] tNbrda; 396 private boolean[] IsAlias; 397 private boolean[] IsColumn; 398 private boolean[] IsStartJOIN; 399 private boolean[] IsStartJOIN_ON; 400 private boolean[] IsStartFROM; 401 private boolean[] IsStartWHERE; 402 private boolean[] IsStartGROUPBY; 403 private boolean[] IsStartORDERBY; 404 private boolean[] blockIsSQL; 405 private boolean[] brStartWithMasterKey; 406 private boolean[] brSurroundsSQL; 407 private boolean[] brSurroundsCondition; 408 private boolean[] brSurroundsCase; 409 private boolean[] brSurroundsParams; 410 private boolean[] brAfterSQLMasterKeyword; 411 private boolean[] brAfterInsertValuesKeyword; 412 private boolean[] brWithCommaLineBreak; 413 private boolean[] brSetPrimaryIndentToCursorPosition; 414 415 private short[] brPrimaryIndentBeforBr; 416 417 // Integer variables 418 private int numberOfLeftBracket; 419 private int MAX_ALIGN_TOKENS; 420 private int bz; 421 private int numberOfStatementPlus10; 422 private int PRE_LOCATED_LINES; 423 private int NUMBER_OF_WHITESPACE; 424 425 private int[] blockIDByToken; 426 private short[] SQLIDByToken; 427 private int[] brStartToken; 428 429 private int[] SQLLength; 430 private short[] bracketsInSQL; 431 private short[] longestMasterKeywordsInSQL; 432 private int[] SQLStartsAtT; 433 private int[] SQLEndsAtT; 434 private short[] SQLPrimaryIndent; 435 private boolean[] SQLStartWithBracket; 436 private boolean[] SQLStartWithComment; 437 private boolean[] SQLbL; 438 private boolean[] SQLIsSubSQL; 439 440 // String variables 441 private String bN; 442 private String bO1; 443 private String bP1; 444 private String debugInstruction; 445 private String tokenSeparator; 446 private StringTokenizer sqlTokens; 447 private StringBuilder solidTokenSB; 448 private StringBuilder formattedSQL; 449 private String solidTokenStr; 450 private String inputSQLText; 451 private StringBuilder bX; 452 private String[] tokenArray; 453 private String[] brPrecedingT; 454 private String[] brSQLMasterKeyword; 455 456 private boolean[] tNbrdl; 457 private boolean[] CanSetLineBreakAfter; 458 private boolean[] tNbrdn; 459 private boolean[] startTokenOfMasterSQL; 460 private String[] BelongsToSPKeyword; 461 462 private boolean[] tNbrProcessThisToken; 463 private byte colorByte; 464 private byte[] tNbrColorRelated; 465 private int[] tNbrOfPrecedingBlanks; 466 private int[] tNbrOfPrecedingBlanks2; 467 private short[] tNbrOfPrecedingLinebreak; 468 private short[] tNbrOfPrecedingLinebreakOutputSQL; 469 private short[] bracketsInBlock; 470 private short[] brPrimaryIndent; 471 private short[] brdz; 472 473 // Integer variables 474 private int lineNumber; 475 private int[] indentOfEachlineWithPaddingSpace; 476 private int[] indentOfEachline; 477 private int[] dR; 478 private int prevTokenPos1; 479 private int prevTokenPos2; 480 private int tmpK; 481 private int posOfSearchedToken; 482 private int sqlTokenLen; 483 private int eb1; 484 private int currentIndentSize; 485 private short linebreakBefore; 486 private short linebreakAfter; 487 private short prevTokenLinebreakAfter; 488 private short ColumnPosOfCurrentToken; 489 private short alignStyle; 490 private short indentLength; 491 private int adjustLeadingSpace; 492 private int reducedLevel; 493 private int reduceAfterToken; 494 private int increasedLevel; 495 private int increaseAfterToken; 496 private String prevKeyword1; 497 private ArrayList<String> functionList; 498 499 // String variables 500 private String prev_no_left_bracket_token; 501 private String prevToken1; 502 private String prevToken2; 503 private String prevprevToken; 504 private String currentKeyword1; 505 private String functionStr; 506 private String sqlplusStr; 507 private String datatypeStr; 508 private String joinStr; 509 private String fromWhereMoreKeywordsStr; 510 private String sqlServerSPRelatedSqlStr; 511 private String[] spaceArray; 512 private String lineSeparator; 513 514 // Boolean variables 515 private boolean ec1; 516 517 // Arrays 518 private String[][] tokenToAlign; 519 private int[][] posOfTokenToAlign; 520 private int[][] lineOfTokenToAlign; 521 private int[][] columnPosOfTokenToAlign; 522 private short[][] numsOfTokenAbleToAlign; 523 private short[][] bracketLevelOfTokenToAlign; 524 private int[] numsOfTokenToAlign; 525 526 public String output_start_line; 527 public String output_start_of_each_line; 528 public String output_end_of_each_line; 529 public String output_end_line; 530 public String literalStr1; 531 public int precedingBlanksOfLiteral; 532 public String blockCommentStr1; 533 public int precedingBlanksOfBlockComment; 534 public String doubleQuotesStr1; 535 public int precedingBlanksOfDoubleQuotes; 536 public boolean inComment1; 537 public boolean inComment2; 538 public boolean findUnnecessaryBracket; 539 public int count1; 540 public int hostVariableRelatedCount; 541 public boolean sqlserverMasterKeyRelatedBoolean; 542 public int sqlserverMasterKeyRelatedLevel; 543 public boolean sqlserverb1; 544 public boolean reduceLevelRelatedB1; 545 public boolean reduceLevelRelatedB2; 546 public Boolean reduceAfterRelatedB1; 547 public boolean reduceLevelRelatedB3; 548 549 // private a fn; 550 public byte colorRelatedB2; 551 552 // Format options 553 public boolean keywordUpper; 554 public boolean onlyKeywordUpper; 555 public boolean keywordLower; 556 public boolean wholeUpper; 557 public boolean wholeLower; 558 public boolean showIndentionLevel; 559 public boolean removeUnnecessayWhiteSpaces; 560 public boolean breaksAroundUnionIntersect; 561 public boolean linebreakBeforeComma; 562 public boolean linebreakAfterComma; 563 public boolean linebreakAfterANDOR; 564 public boolean linebreakBeforeAndOr; 565 public boolean linebreakBeforeConcatenations; 566 public boolean linebreakAfterConcatenations; 567 public boolean showLineNumber; 568 public boolean breakAfterMasterKeyword; 569 public boolean useTab; 570 public boolean formatSQLOn1Line; 571 public String literalQuote; 572 public String outVariableName; 573 public short genericIndentSize; 574 public boolean SQLFromProgram; 575 public String charEncloseSQL; 576 public String outputFormat; 577 public int maxLineWidth; 578 public int numberOfIdentifiersPerLine; 579 public int valuesPerLineForINLists; 580 public String caseCustomizedKeywords; 581 public String caseCustomizedVariableType; 582 public EDbVendor dbname; 583 public boolean indentSubquery; 584 public boolean linebreakBeforeStartParenthesisOfSubquery; 585 public boolean linebreakAfterLeftBracketsOfSubSelect; 586 public boolean linebreakBeforeStartParenthesisOfCondition; 587 public boolean linebreakBeforeEndParenthesisOfSubquery; 588 public boolean linebreakAfterEndParenthesisOfSubquery; 589 public boolean linebreakBeforeEndParenthesisOfCondition; 590 public boolean linebreakAfterEndParenthesisOfCondition; 591 public boolean indentConditionInParenthesis; 592 public boolean linebreakAfterLeftBracketOfACondition; 593 public boolean indentMasterKeyword; 594 public boolean indentANDOR; 595 public boolean indentCaseThen; 596 public boolean indentCaseElse; 597 public boolean colouredSQL; 598 public boolean linebreakForCase; 599 public boolean linebreakBeforeCaseThen; 600 public boolean linebreakBeforeCaseWhen; 601 public boolean linebreakBeforeCaseANDOR; 602 public boolean linebreakBeforeCaseElse; 603 public boolean breakBeforeONkeyword; 604 public boolean alignEqualSigns; 605 public boolean alignOperator; 606 public boolean alignAliasName; 607 public boolean alignCommaInList; 608 public boolean alignLineComment; 609 public boolean alignConcateOP; 610 public boolean SPAlignDeclareVariable; 611 public boolean rightAlignMasterKeywords; 612 public boolean deleteComments; 613 public boolean putCommentBetweenSlashStar; 614 public boolean isRemoveUnnecessaryBracket; 615 public String spaceAroundBracketOption; 616 public String spaceAroundCommaOption; 617 public String spaceAroundOperatorOption; 618 public int smallSQLLen; 619 public int additionalIndent; 620 public boolean linebreakBeforeLineComment; 621 public boolean linebreakBeforeBlockComment; 622 public boolean colorRelatedB1; 623 public boolean indentJoinStatement; 624 public boolean indentOnStatement; 625 public boolean escapeCharacter; 626 public boolean keepEmptyLine; 627 public boolean alignAliasNameAtPredefinedPos; 628 public int alignAliasNamePos; 629 public boolean replaceHostVariable; 630 public boolean putHostVariableBetweenSlashStar; 631 public boolean showPseudoCode; 632 public boolean flexibleSpaceCalculation; 633 public boolean keepFirstLineIndent; 634 public boolean SPLinebreakBeforeStartParenthesisofCondition; 635 public boolean SPLinebreakAfterStartParenthesisofCondition; 636 public boolean SPLinebreakBeforeEndParenthesisofCondition; 637 public boolean SPLinebreakAfterEndParenthesisofCondition; 638 public boolean SPLinebreakBeforeANDORofCondition; 639 public boolean SPLinebreakAfterANDORofCondition; 640 public boolean SPIndentConditionInBracket; 641 public boolean SPLinebreakBeforeStartParenthesisofParameters; 642 public boolean SPLinebreakAfterStartParenthesisofParameters; 643 public boolean SPIndentParameterInBracket; 644 public boolean SPLinebreakBeforeEndParenthesisofParameters; 645 public boolean enableNonFormat; 646 public String nonFormatStartTag; 647 public String nonFormatEndTag; 648 public boolean linebreakBeforeStartParenthesisOfInsert; 649 public boolean linebreakAfterStartParenthesisOfInsert; 650 public boolean linebreakBeforeEndParenthesisOfInsert; 651 public boolean linebreakAfterEndParenthesisOfInsert; 652 public boolean indentColumnValueOfInsert; 653 public boolean linebreakBeforeStartParenthesisOfCase; 654 public boolean linebreakAfterStartParenthesisOfCase; 655 public boolean linebreakBeforeEndParenthesisOfCase; 656 public boolean linebreakAfterEndParenthesisOfCase; 657 public boolean indentCaseInBracket; 658 public boolean leftAlignBlockComment; 659 public boolean indentBlockComment; 660 public boolean moveComma2colsToTheLeft; 661 public boolean alwaysPut1SpaceAfterComma; 662 public int colorOfMasterKeyword; 663 public int colorOfLineComment; 664 public int colorOfBlockComment; 665 public int colorOfCASEKeyword; 666 public int colorOfLiteral; 667 public int colorOfReservedWords; 668 669// public static final String[] commonFunctions = new String[] { "abs", "add", "after", "alias", "all", "alter", "and", 670// "any", "as", "asc", "atomic", "avg", "alter procedure", "alter table", "begin catch", "begin tran", 671// "Begin Transaction", "begin try", "begin", "between", "binary", "bit", "blob", "boolean", "break", "by", 672// "call", "cascade", "case", "cast", "char", "char_convert", "character", "check", "checkpoint", "chr", 673// "clob", "close", "coalesce", "comment", "commit", "connect", "constraint", "continue", "convert", "count", 674// "create", "cross", "current", "current_date", "current_time", "current_timestamp", "cursor", "connect by", 675// "create function", "create procedure", "create view", "create table", "create index", "create unique index", 676// "cross join", "date", "dateadd", "datediff", "datename", "datepart", "datetime", "day", "dba", "dbo", 677// "dbspace", "deallocate", "dec", "decimal", "declare", "decode", "default", "delete", "desc", "distinct", 678// "do", "double", "drop", "drop procedure", "drop table", "each", "else", "elseif", "encrypted", "end", 679// "endif", "escape", "exception", "exception join", "exec", "execute", "exists", "exit", "end catch", 680// "end try", "fetch", "first", "float", "for", "foreign", "from", "full", "function", "full inner join", 681// "full join", "full outer join", "getdate", "getutcdate", "go", "goto", "grant", "group", "group by", 682// "having", "holdlock", "identified", "if", "in", "index", "initial", "inner", "inner join", "inout", 683// "insert", "instead", "int", "integer", "into", "is", "is distinct from", "is not distinct from", 684// "isolation", "is not null", "is null", "isnull", "join", "key", "left join", "left exception join", 685// "left outer join", "left", "len", "length", "like", "lock", "long", "loop", "match", "max", "membership", 686// "message", "min", "mode", "modify", "month", "money", "named", "natural", "nclob", "new", "next", 687// "noholdlock", "nolock", "not", "not like", "ntext", "null", "nullif", "number", "numeric", "varchar", "nvl", 688// "of", "off", "old", "on", "open", "option", "options", "or", "order", "others", "out", "outer", "order by", 689// "order siblings by", "outer join", "package", "passthrough", "pctincrease", "precision", "prepare", 690// "primary", "print", "privileges", "proc", "procedure", "raiserror", "readtext", "real", "reference", 691// "references", "referencing", "release", "remote", "rename", "replace", "replicate", "resource", "restrict", 692// "return", "revoke", "right", "rollback", "round", "right join", "right exception join", "right outer join", 693// "Rollback Transaction", "rtrim", "save", "savepoint", "schedule", "select", "set", "share", "sign", 694// "simple_integer", "smallint", "snapshot", "some", "sql", "sqlcode", "sqlid", "sqlstate", "start", 695// "statement", "stop", "storage", "substr", "subtrans", "subtransaction", "sum", "synchronize", "synonym", 696// "syntax_error", "sys", "select distinct", "sort by", "start with", "sysdate", "table", "tablespace", 697// "temporary", "then", "time", "timestamp", "timestmp", "tinyint", "to", "to_char", "tran", "translate", 698// "trigger", "trunc", "truncate", "tsequal", "truncate table", "union all", "union", "unique", "unknown", 699// "update", "upper", "use", "user", "using", "validate", "values", "varbinary", "varchar2", "varchar", 700// "variable", "varying", "view", "when", "where", "while", "with", "work", "writetext", "year" }; 701// 702// public static final String[] teradataFunctions = new String[] { "abort", "abortsession", "abs", "access_lock", 703// "account", "acos", "acosh", "add", "add_months", "admin", "after", "aggregate", "all", "alter", "amp", 704// "and", "ansidate", "any", "arglparen", "as", "asc", "asin", "asinh", "at", "atan", "atan2", "atanh", 705// "atomic", "authorization", "ave", "average", "avg", "before", "begin", "between", "bigint", "binary", 706// "blob", "both", "bt", "but", "by", "byte", "byteint", "bytes", "call", "case", "casespecific", "case_n", 707// "cast", "cd", "char", "char2hexint", "character", "characters", "character_length", "chars", "char_length", 708// "check", "checkpoint", "class", "clob", "close", "cluster", "cm", "coalesce", "collation", "collect", 709// "column", "comment", "commit", "compress", "constraint", "constructor", "consume", "contains", "continue", 710// "convert_table_header", "corr", "cos", "cosh", "count", "covar_pop", "covar_samp", "create", "cross", "cs", 711// "csum", "ct", "cube", "current", "current_date", "current_time", "current_timestamp", "cursor", "cv", 712// "cycle", "database", "datablocksize", "date", "dateform", "day", "deallocate", "dec", "decimal", "declare", 713// "default", "deferred", "degrees", "del", "delete", "desc", "deterministic", "diagnostic", "disabled", 714// "distinct", "do", "domain", "double", "drop", "dual", "dump", "dynamic", "each", "echo", "else", "elseif", 715// "enabled", "end", "eq", "myequals", "error", "errorfiles", "errortables", "escape", "et", "except", "exec", 716// "execute", "exists", "exit", "exp", "explain", "external", "extract", "fallback", "fastexport", "fetch", 717// "first", "float", "for", "foreign", "format", "found", "freespace", "from", "full", "function", "ge", 718// "generated", "give", "grant", "graphic", "group", "grouping", "gt", "handler", "hash", "hashamp", 719// "hashbakamp", "hashbucket", "hashrow", "having", "help", "hour", "identity", "if", "immediate", "in", 720// "inconsistent", "index", "initiate", "inner", "inout", "input", "ins", "insert", "instance", "instead", 721// "int", "integer", "integerdate", "intersect", "interval", "into", "is", "iterate", "jar", "join", "journal", 722// "key", "kurtosis", "language", "large", "le", "leading", "leave", "left", "like", "limit", "ln", "loading", 723// "local", "locator", "lock", "locking", "log", "logging", "logon", "long", "loop", "lower", "lt", "macro", 724// "map", "mavg", "max", "maximum", "mcharacters", "mdiff", "merge", "method", "min", "mindex", "minimum", 725// "minus", "minute", "mlinreg", "mload", "mod", "mode", "modifies", "modify", "monitor", "monresource", 726// "monsession", "month", "msubstr", "msum", "multiset", "named", "natural", "ne", "new", "new_table", "next", 727// "no", "none", "not", "nowait", "null", "nullif", "nullifzero", "numeric", "object", "objects", 728// "octet_length", "of", "off", "old", "old_table", "on", "only", "open", "option", "or", "order", "ordering", 729// "out", "outer", "over", "overlaps", "override", "parameter", "password", "percent", "percent_rank", "perm", 730// "permanent", "position", "precision", "prepare", "preserve", "primary", "privileges", "procedure", 731// "profile", "protection", "public", "qualified", "qualify", "quantile", "queue", "radians", "random", 732// "range_n", "rank", "reads", "real", "recursive", "references", "referencing", "regr_avgx", "regr_avgy", 733// "regr_count", "regr_intercept", "regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "relative", 734// "release", "rename", "repeat", "replace", "replcontrol", "replication", "request", "restart", "restore", 735// "result", "resume", "ret", "retrieve", "return", "returns", "revalidate", "revoke", "right", "rights", 736// "role", "rollback", "rollforward", "rollup", "row", "rowid", "rows", "row_number", "sample", "sampleid", 737// "scroll", "second", "sel", "select", "session", "set", "setresrate", "sets", "setsessrate", "show", "sin", 738// "sinh", "skew", "smallint", "some", "soundex", "specific", "spool", "sql", "sqlexception", "sqltext", 739// "sqlwarning", "sqrt", "ss", "start", "startup", "statement", "statistics", "stddev_pop", "stddev_samp", 740// "stepinfo", "string_cs", "subscriber", "substr", "substring", "sum", "summary", "suspend", "table", "tan", 741// "tanh", "tbl_cs", "temporary", "terminate", "then", "threshold", "time", "timestamp", "timezone_hour", 742// "timezone_minute", "title", "to", "top", "trace", "trailing", "transaction", "transform", "translate", 743// "translate_chk", "trigger", "trim", "type", "uc", "udtcastas", "udtcastlparen", "udtmethod", "udttype", 744// "udtusage", "uescape", "undefined", "undo", "union", "unique", "until", "upd", "update", "upper", 745// "uppercase", "user", "using", "value", "values", "varbyte", "varchar", "vargraphic", "varying", "var_pop", 746// "var_samp", "view", "volatile", "when", "where", "while", "width_bucket", "with", "without", "work", "year", 747// "zeroifnull", "zone" }; 748 749 public static final char SPACE = 32; 750 public static final char FORM_FEED = 12; // \f in Java 751 public static final char BACKSPACE = 8; // \b in Java 752 public static final char CARRIAGE_RETURN = 13; // \r in Java, carriage return 753 public static final char LINE_FEED = 10; // \n in Java, line feed 754 public static final char BACKSLASH = 92; // \\ in Java, backslash 755 public static final char LEFT_PARENTHESIS = 40; // ( in Java 756 757 public static final String[] tokenSeparatorArray = { " ", "[", "]", "|", "+", "-", "`", "/", "*", ":", ";", ",", 758 "(", ")", "!", "<", ">", "=", "\\", "\n", "\t", "\f", "\r", "\b", "'", "\"" }; 759 public static final String c_char_exclamation = String.valueOf((char) 33); // ! 760 public static final String c_char_pound = String.valueOf((char) 35); // # 761 public static final String c_char_percent = String.valueOf((char) 37); // % 762 public static final String c_char_left_paren = String.valueOf((char) 40); // ( 763 public static final String c_char_right_paren = String.valueOf((char) 41); // ) 764 public static final String c_char_star = String.valueOf((char) 42); // * 765 public static final String c_char_plus = String.valueOf((char) 43); // + 766 public static final String c_char_coma = String.valueOf((char) 44); // , 767 public static final String c_char_minus = String.valueOf((char) 45); // - 768 public static final String c_char_dot = String.valueOf((char) 46); // . 769 public static final String c_char_divide = String.valueOf((char) 47); // / 770 public static final String c_char_colon = String.valueOf((char) 58); // : 771 public static final String c_char_semicolon = String.valueOf((char) 59); // ; 772 public static final String c_char_less = String.valueOf((char) 60); // < 773 public static final String c_char_equal = String.valueOf((char) 61); // = 774 public static final String c_char_great = String.valueOf((char) 62); // > 775 public static final String c_char_question_mark = String.valueOf((char) 63); // ? 776 public static final String c_char_at = String.valueOf((char) 64); // @ 777 public static final String c_char_vertical_bar = String.valueOf((char) 124); // | 778 779 public static final String c_predefined_sep = c_char_at; 780 781 public static final int encrypt_key = 33189; 782 783 public static class TTextTokenizer { 784 protected List<String> tokens; 785 protected List<String> delimiters; 786 787 public TTextTokenizer() { 788 tokens = new ArrayList<>(); 789 delimiters = new ArrayList<>(); 790 } 791 792 public void tokenize(String text) { 793 tokens.clear(); 794 String[] parts = text.split(String.join("|", delimiters)); 795 tokens.addAll(Arrays.asList(parts)); 796 } 797 798 public void addDelimiters(String... delimiters) { 799 this.delimiters.addAll(Arrays.asList(delimiters)); 800 } 801 802 public List<String> getTokens() { 803 return tokens; 804 } 805 } 806 807 public static class TStringTokenizer extends TTextTokenizer { 808 private String inputsql; 809 private int curPos; 810 811 public TStringTokenizer(String finputsql, String... tokenSep) { 812 inputsql = finputsql; 813 curPos = 0; 814 addDelimiters(tokenSep); 815 tokenize(inputsql); 816 } 817 818 public int countTokens() { 819 return tokens.size(); 820 } 821 822 public boolean hasMoreTokens() { 823 return curPos < tokens.size(); 824 } 825 826 public String nextToken() { 827 if (!hasMoreTokens()) { 828 return null; 829 } 830 return tokens.get(curPos++); 831 } 832 } 833 834 private static final int C1 = 54358; 835 private static final int C2 = 22973; 836 private static final int encryptKey = 33189; 837 838 private static final byte[] Map = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 839 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 840 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 63, 52, 53, 841 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 842 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 843 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30, 844 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 845 46, 47, 48, 49, 50, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 846 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 847 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 848 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 849 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 850 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 851 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 852 0 }; 853 854 public static String decode(String input) { 855 if (input.length() != 2 && input.length() != 3 && input.length() != 4) { 856 throw new IllegalArgumentException("Invalid input length"); 857 } 858 859 int length = input.length(); 860 long I; 861 byte[] Result = new byte[0]; 862 switch (length) { 863 case 2: 864 I = Map[input.charAt(0)] + (Map[input.charAt(1)] << 6); 865 Result[0] = (byte) I; 866 break; 867 case 3: 868 I = Map[input.charAt(0)] + (Map[input.charAt(1)] << 6) + (Map[input.charAt(2)] << 12); 869 Result = new byte[2]; 870 Result[0] = (byte) (I & 0xFF); 871 Result[1] = (byte) ((I >> 8) & 0xFF); 872 break; 873 case 4: 874 I = Map[input.charAt(0)] + (Map[input.charAt(1)] << 6) + (Map[input.charAt(2)] << 12) 875 + (Map[input.charAt(3)] << 18); 876 Result = new byte[3]; 877 Result[0] = (byte) (I & 0xFF); 878 Result[1] = (byte) ((I >> 8) & 0xFF); 879 Result[2] = (byte) ((I >> 16) & 0xFF); 880 break; 881 } 882 return new String(Result); 883 } 884 885 public static String preProcess(String s) { 886 return new String(java.util.Base64.getDecoder().decode(s)); 887 } 888 889 public static String internalDecrypt(String s, int key) { 890 StringBuilder result = new StringBuilder(s); 891 int seed = key; 892 for (int i = 0; i < result.length(); i++) { 893 result.setCharAt(i, (char) (result.charAt(i) ^ (seed >> 8))); 894 seed = (result.charAt(i) + seed) * C1 + C2; 895 } 896 return result.toString(); 897 } 898 899 public static String decrypt(String input, int key) { 900 return internalDecrypt(preProcess(input), key); 901 } 902 903 public static String myDecrypt(String input) { 904 return decrypt(input, encryptKey); 905 } 906 907 public static String encode(String s) { 908 long i = 0; 909 byte[] bytes = s.getBytes(); 910 for (int j = 0; j < bytes.length; j++) { 911 i |= (bytes[j] << (8 * (bytes.length - 1 - j))); 912 } 913 StringBuilder result = new StringBuilder(); 914 switch (bytes.length) { 915 case 1: 916 result.append(Map[(int) (i % 64)]); 917 result.append(Map[(int) ((i >> 6) % 64)]); 918 break; 919 case 2: 920 result.append(Map[(int) (i % 64)]); 921 result.append(Map[(int) ((i >> 6) % 64)]); 922 result.append(Map[(int) ((i >> 12) % 64)]); 923 break; 924 case 3: 925 result.append(Map[(int) (i % 64)]); 926 result.append(Map[(int) ((i >> 6) % 64)]); 927 result.append(Map[(int) ((i >> 12) % 64)]); 928 result.append(Map[(int) ((i >> 18) % 64)]); 929 break; 930 default: 931 throw new IllegalArgumentException("Invalid length: " + bytes.length); 932 } 933 return result.toString(); 934 } 935 936 public static String postProcess(String s) { 937 StringBuilder result = new StringBuilder(); 938 String ss = s; 939 while (!ss.isEmpty()) { 940 result.append(encode(ss.substring(0, Math.min(3, ss.length())))); 941 ss = ss.substring(Math.min(3, ss.length())); 942 } 943 return result.toString(); 944 } 945 946 public static String internalEncrypt(String s, int key) { 947 String result = s; 948 int seed = key; 949 for (int i = 0; i < result.length(); i++) { 950 result = result.substring(0, i) + (char) (result.charAt(i) ^ (seed >> 8)) + result.substring(i + 1); 951 seed = (byte) result.charAt(i) + seed * C1 + C2; 952 } 953 return result; 954 } 955 956 public static String encrypt(String s, int key) { 957 return postProcess(internalEncrypt(s, key)); 958 } 959 960 public static boolean includeStr(String substr, String str) { 961 return str.toLowerCase().contains(substr.toLowerCase()); 962 } 963 964 public static String replaceAll(String s, String search, String replace) { 965 return s.replaceAll(search, replace); 966 } 967 968 public static boolean myequals(String src, String dest) { 969 return src.equalsIgnoreCase(dest); 970 } 971 972 public static boolean equalsIgnoreCase(String src, String dest) { 973 if (src.length() != dest.length()) 974 return false; 975 return src.compareToIgnoreCase(dest) == 0; 976 } 977 978 public static boolean equalsToChar(String src, char dest) { 979 return src.length() == 1 && src.charAt(0) == dest; 980 } 981 982 public static boolean equalsToChar(String src, String dest) { 983 return src.length() == 1 && src.charAt(0) == dest.charAt(0); 984 } 985 986 public static String toLowerCase(String s) { 987 StringBuilder result = new StringBuilder(); 988 for (int i = 0; i < s.length(); i++) { 989 char ch = s.charAt(i); 990 if (ch >= 'A' && ch <= 'Z') { 991 ch += 32; 992 } 993 result.append(ch); 994 } 995 return result.toString(); 996 } 997 998 public static boolean startsWith(String src, String pattern) { 999 return src.toLowerCase().startsWith(pattern.toLowerCase()); 1000 } 1001 1002 public static boolean endsWith(String src, String pattern) { 1003 return src.toLowerCase().endsWith(pattern.toLowerCase()); 1004 } 1005 1006 public static boolean myTryStrToInt(String S, int[] Value) { 1007 boolean result = false; 1008 if (S.length() == 0) return false; 1009 if (S.charAt(0) == 'x') return false; 1010 try { 1011 Value[0] = Integer.parseInt(S); 1012 result = true; 1013 } catch (NumberFormatException e) { 1014 // Parsing failed 1015 result = false; 1016 } 1017 return result; 1018 } 1019 1020 public SQLion(EDbVendor vendor, GFmtOpt option) { 1021 commonFunctions1 = "abs@add@after@alias@all@alter@and@any@as@asc";//'abs@add@after@alias@all@alter@and@any@as@asc'; 1022 commonFunctions2 = "@atomic@avg@alter procedure@alter table@begin catch@begin tran@Begin Transaction@begin try@begin@between";//'@atomic@avg@alter procedure@alter table@begin catch@begin tran@Begin Transaction@begin try@begin@between'; 1023 commonFunctions3 = "@binary@bit@blob@boolean@break@by@call@cascade@case@cast";//'@binary@bit@blob@boolean@break@by@call@cascade@case@cast'; 1024 commonFunctions4 = "@char@char_convert@character@check@checkpoint@chr@clob@close@coalesce@comment";//'@char@char_convert@character@check@checkpoint@chr@clob@close@coalesce@comment'; 1025 commonFunctions5 = "@commit@connect@constraint@continue@convert@count@create@cross@current@current_date";//'@commit@connect@constraint@continue@convert@count@create@cross@current@current_date'; 1026 commonFunctions6 = "@current_time@current_timestamp@cursor@connect by@create function@create procedure@create view@create table@create index@create unique index";//'@current_time@current_timestamp@cursor@connect by@create function@create procedure@create view@create table@create index@create unique index'; 1027 commonFunctions7 = "@cross join@date@dateadd@datediff@datename@datepart@datetime@day@dba@dbo";//'@cross join@date@dateadd@datediff@datename@datepart@datetime@day@dba@dbo'; 1028 commonFunctions8 = "@dbspace@deallocate@dec@decimal@declare@decode@default@delete@desc@distinct";//'@dbspace@deallocate@dec@decimal@declare@decode@default@delete@desc@distinct'; 1029 commonFunctions9 = "@do@double@drop@drop procedure@drop table@each@else@elseif@encrypted@end";//'@do@double@drop@drop procedure@drop table@each@else@elseif@encrypted@end'; 1030 commonFunctions10 = "@endif@escape@exception@exception join@exec@execute@exists@exit@end catch@end try";//'@endif@escape@exception@exception join@exec@execute@exists@exit@end catch@end try'; 1031 commonFunctions11 = "@fetch@first@float@for@foreign@from@full@function@full inner join@full join";//'@fetch@first@float@for@foreign@from@full@function@full inner join@full join'; 1032 commonFunctions12 = "@full outer join@getdate@getutcdate@go@goto@grant@group@group by@having@holdlock";//'@full outer join@getdate@getutcdate@go@goto@grant@group@group by@having@holdlock'; 1033 commonFunctions13 = "@identified@if@in@index@initial@inner@inner join@inout@insert@instead";//'@identified@if@in@index@initial@inner@inner join@inout@insert@instead'; 1034 commonFunctions14 = "@int@integer@into@is@is distinct from@is not distinct from@isolation@is not null@is null@isnull";//'@int@integer@into@is@is distinct from@is not distinct from@isolation@is not null@is null@isnull'; 1035 commonFunctions15 = "@join@key@left join@left exception join@left outer join@left@len@length@like@lock";//'@join@key@left join@left exception join@left outer join@left@len@length@like@lock'; 1036 commonFunctions16 = "@long@loop@match@max@membership@message@min@mode@modify@month";//'@long@loop@match@max@membership@message@min@mode@modify@month'; 1037 commonFunctions17 = "@money@named@natural@nclob@new@next@noholdlock@nolock@not@not like";//'@money@named@natural@nclob@new@next@noholdlock@nolock@not@not like'; 1038 commonFunctions18 = "@ntext@null@nullif@number@numeric@varchar@nvl@of@off@old";//'@ntext@null@nullif@number@numeric@varchar@nvl@of@off@old'; 1039 commonFunctions19 = "@on@open@option@options@or@order@others@out@outer@order by";//'@on@open@option@options@or@order@others@out@outer@order by'; 1040 commonFunctions20 = "@order siblings by@outer join@package@passthrough@pctincrease@precision@prepare@primary@print@privileges";//'@order siblings by@outer join@package@passthrough@pctincrease@precision@prepare@primary@print@privileges'; 1041 commonFunctions21 = "@proc@procedure@raiserror@readtext@real@reference@references@referencing@release@remote";//'@proc@procedure@raiserror@readtext@real@reference@references@referencing@release@remote'; 1042 commonFunctions22 = "@rename@replace@replicate@resource@restrict@return@revoke@right@rollback@round";//'@rename@replace@replicate@resource@restrict@return@revoke@right@rollback@round'; 1043 commonFunctions23 = "@right join@right exception join@right outer join@Rollback Transaction@rtrim@save@savepoint@schedule@select@set";//'@right join@right exception join@right outer join@Rollback Transaction@rtrim@save@savepoint@schedule@select@set'; 1044 commonFunctions24 = "@share@sign@simple_integer@smallint@snapshot@some@sql@sqlcode@sqlid@sqlstate";//'@share@sign@simple_integer@smallint@snapshot@some@sql@sqlcode@sqlid@sqlstate'; 1045 commonFunctions25 = "@start@statement@stop@storage@substr@subtrans@subtransaction@sum@synchronize@synonym";//'@start@statement@stop@storage@substr@subtrans@subtransaction@sum@synchronize@synonym'; 1046 commonFunctions26 = "@syntax_error@sys@select distinct@sort by@start with@sysdate@table@tablespace@temporary@then";//'@syntax_error@sys@select distinct@sort by@start with@sysdate@table@tablespace@temporary@then'; 1047 commonFunctions27 = "@time@timestamp@timestmp@tinyint@to@to_char@tran@translate@trigger@trunc";//'@time@timestamp@timestmp@tinyint@to@to_char@tran@translate@trigger@trunc'; 1048 commonFunctions28 = "@truncate@tsequal@truncate table@union all@union@unique@unknown@update@upper@use";//'@truncate@tsequal@truncate table@union all@union@unique@unknown@update@upper@use'; 1049 commonFunctions29 = "@user@using@validate@values@varbinary@varchar2@varchar@variable@varying@view";//'@user@using@validate@values@varbinary@varchar2@varchar@variable@varying@view'; 1050 commonFunctions30 = "@when@where@while@with@work@writetext@year";//'@when@where@while@with@work@writetext@year'; 1051 1052 TeradataFunctions1 = "abort@abortsession@abs@access_lock@account@acos@acosh@add@add_months@admin";//'abort@abortsession@abs@access_lock@account@acos@acosh@add@add_months@admin'; 1053 TeradataFunctions2 = "@after@aggregate@all@alter@amp@and@ansidate@any@arglparen@as";//'@after@aggregate@all@alter@amp@and@ansidate@any@arglparen@as'; 1054 TeradataFunctions3 = "@asc@asin@asinh@at@atan@atan2@atanh@atomic@authorization@ave";//'@asc@asin@asinh@at@atan@atan2@atanh@atomic@authorization@ave'; 1055 TeradataFunctions4 = "@average@avg@before@begin@between@bigint@binary@blob@both@bt";//'@average@avg@before@begin@between@bigint@binary@blob@both@bt'; 1056 TeradataFunctions5 = "@but@by@byte@byteint@bytes@call@case@casespecific@case_n@cast";//'@but@by@byte@byteint@bytes@call@case@casespecific@case_n@cast'; 1057 TeradataFunctions6 = "@cd@char@char2hexint@character@characters@character_length@chars@char_length@check@checkpoint";//'@cd@char@char2hexint@character@characters@character_length@chars@char_length@check@checkpoint'; 1058 TeradataFunctions7 = "@class@clob@close@cluster@cm@coalesce@collation@collect@column@comment";//'@class@clob@close@cluster@cm@coalesce@collation@collect@column@comment'; 1059 TeradataFunctions8 = "@commit@compress@constraint@constructor@consume@contains@continue@convert_table_header@corr@cos";//'@commit@compress@constraint@constructor@consume@contains@continue@convert_table_header@corr@cos'; 1060 TeradataFunctions9 = "@cosh@count@covar_pop@covar_samp@create@cross@cs@csum@ct@cube";//'@cosh@count@covar_pop@covar_samp@create@cross@cs@csum@ct@cube'; 1061 TeradataFunctions10 = "@current@current_date@current_time@current_timestamp@cursor@cv@cycle@database@datablocksize@date";//'@current@current_date@current_time@current_timestamp@cursor@cv@cycle@database@datablocksize@date'; 1062 TeradataFunctions11 = "@dateform@day@deallocate@dec@decimal@declare@default@deferred@degrees@del";//'@dateform@day@deallocate@dec@decimal@declare@default@deferred@degrees@del'; 1063 TeradataFunctions12 = "@delete@desc@deterministic@diagnostic@disabled@distinct@do@domain@double@drop";//'@delete@desc@deterministic@diagnostic@disabled@distinct@do@domain@double@drop'; 1064 TeradataFunctions13 = "@dual@dump@dynamic@each@echo@else@elseif@enabled@end@eq";//'@dual@dump@dynamic@each@echo@else@elseif@enabled@end@eq'; 1065 TeradataFunctions14 = "@myequals@error@errorfiles@errortables@escape@et@except@exec@execute@exists";//'@myequals@error@errorfiles@errortables@escape@et@except@exec@execute@exists'; 1066 TeradataFunctions15 = "@exit@exp@explain@external@extract@fallback@fastexport@fetch@first@float";//'@exit@exp@explain@external@extract@fallback@fastexport@fetch@first@float'; 1067 TeradataFunctions16 = "@for@foreign@format@found@freespace@from@full@function@ge@generated";//'@for@foreign@format@found@freespace@from@full@function@ge@generated'; 1068 TeradataFunctions17 = "@give@grant@graphic@group@grouping@gt@handler@hash@hashamp@hashbakamp";//'@give@grant@graphic@group@grouping@gt@handler@hash@hashamp@hashbakamp'; 1069 TeradataFunctions18 = "@hashbucket@hashrow@having@help@hour@identity@if@immediate@in@inconsistent";//'@hashbucket@hashrow@having@help@hour@identity@if@immediate@in@inconsistent'; 1070 TeradataFunctions19 = "@index@initiate@inner@inout@input@ins@insert@instance@instead@int";//'@index@initiate@inner@inout@input@ins@insert@instance@instead@int'; 1071 TeradataFunctions20 = "@integer@integerdate@intersect@interval@into@is@iterate@jar@join@journal";//'@integer@integerdate@intersect@interval@into@is@iterate@jar@join@journal'; 1072 TeradataFunctions21 = "@key@kurtosis@language@large@le@leading@leave@left@like@limit";//'@key@kurtosis@language@large@le@leading@leave@left@like@limit'; 1073 TeradataFunctions22 = "@ln@loading@local@locator@lock@locking@log@logging@logon@long";//'@ln@loading@local@locator@lock@locking@log@logging@logon@long'; 1074 TeradataFunctions23 = "@loop@lower@lt@macro@map@mavg@max@maximum@mcharacters@mdiff";//'@loop@lower@lt@macro@map@mavg@max@maximum@mcharacters@mdiff'; 1075 TeradataFunctions24 = "@merge@method@min@mindex@minimum@minus@minute@mlinreg@mload@mod";//'@merge@method@min@mindex@minimum@minus@minute@mlinreg@mload@mod'; 1076 TeradataFunctions25 = "@mode@modifies@modify@monitor@monresource@monsession@month@msubstr@msum@multiset";//'@mode@modifies@modify@monitor@monresource@monsession@month@msubstr@msum@multiset'; 1077 TeradataFunctions26 = "@named@natural@ne@new@new_table@next@no@none@not@nowait";//'@named@natural@ne@new@new_table@next@no@none@not@nowait'; 1078 TeradataFunctions27 = "@null@nullif@nullifzero@numeric@object@objects@octet_length@of@off@old";//'@null@nullif@nullifzero@numeric@object@objects@octet_length@of@off@old'; 1079 TeradataFunctions28 = "@old_table@on@only@open@option@or@order@ordering@out@outer";//'@old_table@on@only@open@option@or@order@ordering@out@outer'; 1080 TeradataFunctions29 = "@over@overlaps@override@parameter@password@percent@percent_rank@perm@permanent@position";//'@over@overlaps@override@parameter@password@percent@percent_rank@perm@permanent@position'; 1081 TeradataFunctions30 = "@precision@prepare@preserve@primary@privileges@procedure@profile@protection@public@qualified";//'@precision@prepare@preserve@primary@privileges@procedure@profile@protection@public@qualified'; 1082 TeradataFunctions31 = "@qualify@quantile@queue@radians@random@range_n@rank@reads@real@recursive";//'@qualify@quantile@queue@radians@random@range_n@rank@reads@real@recursive'; 1083 TeradataFunctions32 = "@references@referencing@regr_avgx@regr_avgy@regr_count@regr_intercept@regr_r2@regr_slope@regr_sxx@regr_sxy";//'@references@referencing@regr_avgx@regr_avgy@regr_count@regr_intercept@regr_r2@regr_slope@regr_sxx@regr_sxy'; 1084 TeradataFunctions33 = "@regr_syy@relative@release@rename@repeat@replace@replcontrol@replication@request@restart";//'@regr_syy@relative@release@rename@repeat@replace@replcontrol@replication@request@restart'; 1085 TeradataFunctions34 = "@restore@result@resume@ret@retrieve@return@returns@revalidate@revoke@right";//'@restore@result@resume@ret@retrieve@return@returns@revalidate@revoke@right'; 1086 TeradataFunctions35 = "@rights@role@rollback@rollforward@rollup@row@rowid@rows@row_number@sample";//'@rights@role@rollback@rollforward@rollup@row@rowid@rows@row_number@sample'; 1087 TeradataFunctions36 = "@sampleid@scroll@second@sel@select@session@set@setresrate@sets@setsessrate";//'@sampleid@scroll@second@sel@select@session@set@setresrate@sets@setsessrate'; 1088 TeradataFunctions37 = "@show@sin@sinh@skew@smallint@some@soundex@specific@spool@sql";//'@show@sin@sinh@skew@smallint@some@soundex@specific@spool@sql'; 1089 TeradataFunctions38 = "@sqlexception@sqltext@sqlwarning@sqrt@ss@start@startup@statement@statistics@stddev_pop";//'@sqlexception@sqltext@sqlwarning@sqrt@ss@start@startup@statement@statistics@stddev_pop'; 1090 TeradataFunctions39 = "@stddev_samp@stepinfo@string_cs@subscriber@substr@substring@sum@summary@suspend@table";//'@stddev_samp@stepinfo@string_cs@subscriber@substr@substring@sum@summary@suspend@table'; 1091 TeradataFunctions40 = "@tan@tanh@tbl_cs@temporary@terminate@then@threshold@time@timestamp@timezone_hour";//'@tan@tanh@tbl_cs@temporary@terminate@then@threshold@time@timestamp@timezone_hour'; 1092 TeradataFunctions41 = "@timezone_minute@title@to@top@trace@trailing@transaction@transform@translate@translate_chk";//'@timezone_minute@title@to@top@trace@trailing@transaction@transform@translate@translate_chk'; 1093 TeradataFunctions42 = "@trigger@trim@type@uc@udtcastas@udtcastlparen@udtmethod@udttype@udtusage@uescape";//'@trigger@trim@type@uc@udtcastas@udtcastlparen@udtmethod@udttype@udtusage@uescape'; 1094 TeradataFunctions43 = "@undefined@undo@union@unique@until@upd@update@upper@uppercase@user";//'@undefined@undo@union@unique@until@upd@update@upper@uppercase@user'; 1095 TeradataFunctions44 = "@using@value@values@varbyte@varchar@vargraphic@varying@var_pop@var_samp@view";//'@using@value@values@varbyte@varchar@vargraphic@varying@var_pop@var_samp@view'; 1096 TeradataFunctions45 = "@volatile@when@where@while@width_bucket@with@without@work@year@zeroifnull";//'@volatile@when@where@while@width_bucket@with@without@work@year@zeroifnull'; 1097 TeradataFunctions46 = "@zone";//'@zone'; 1098 1099 commonFunctions = commonFunctions1+commonFunctions2+commonFunctions3+commonFunctions4+commonFunctions5+commonFunctions6+commonFunctions7+commonFunctions8+commonFunctions9+commonFunctions10 1100 +commonFunctions11+commonFunctions12+commonFunctions13+commonFunctions14+commonFunctions15+commonFunctions16+commonFunctions17+commonFunctions18+commonFunctions19+commonFunctions20 1101 +commonFunctions21+commonFunctions22+commonFunctions23+commonFunctions24+commonFunctions25+commonFunctions26+commonFunctions27+commonFunctions28+commonFunctions29+commonFunctions30 1102 ; 1103 1104 1105 TeradataFunctions = TeradataFunctions1+TeradataFunctions2+TeradataFunctions3+TeradataFunctions4+TeradataFunctions5+TeradataFunctions6+TeradataFunctions7+TeradataFunctions8+TeradataFunctions9+TeradataFunctions10 1106 +TeradataFunctions11+TeradataFunctions12+TeradataFunctions13+TeradataFunctions14+TeradataFunctions15+TeradataFunctions16+TeradataFunctions17+TeradataFunctions18+TeradataFunctions19+TeradataFunctions20 1107 +TeradataFunctions21+TeradataFunctions22+TeradataFunctions23+TeradataFunctions24+TeradataFunctions25+TeradataFunctions26+TeradataFunctions27+TeradataFunctions28+TeradataFunctions29+TeradataFunctions30 1108 +TeradataFunctions31+TeradataFunctions32+TeradataFunctions33+TeradataFunctions34+TeradataFunctions35+TeradataFunctions36+TeradataFunctions37+TeradataFunctions38+TeradataFunctions39+TeradataFunctions40 1109 +TeradataFunctions41+TeradataFunctions42+TeradataFunctions43+TeradataFunctions44+TeradataFunctions45+TeradataFunctions46 1110 ; 1111 1112 c_numberOfSpace_1 = "1"; 1113 c_numberOfSpace_n = "n"; 1114 c_numberOfSpace_m1 = "M1"; //'M1'; 1115 1116 c_functionStr1 = "@abs@avg@between@case@cast@char@char_convert@character@chr@coalesce@convert@count@current_date@current_time@current_timestamp@cursor@date@dateadd"; 1117 c_functionStr2 = "@datediff@datename@datepart@datetime@day@dec@decimal@decode@default@distinct@double@else@elseif@group by@@if@in@left@len@length@like@match@max@min@month@named"; 1118 c_functionStr3 = "@natural@nclob@new@next@number@numeric@nvl@real@round@rtrim@sign@smallint@substr@sum@synchronize@synonym@time@timestamp@timestmp@tinyint@to_char@tran@translate@unique@upper@validate@varbinary@varchar2@varchar@variable@varying@year@"; 1119 1120 c_sqlplusStr1 = "@accept@append@archive@attribute@break@btitle@change@clear@commit@column@compute@connect@copy@define@del@describe@disconnect@edit@execute@exit@get@help@host@input@list@password@pause@print@prompt@quit@recover@remark@repfooter"; 1121 c_sqlplusStr2 = "@repheader@rollback@run@save@set@show@shutdown@spool@start@startup@store@timing@ttitle@undefine@variable@whenever@"; 1122 1123 c_datatypeStr = "@%rowtype@%type@bigint@binary@bit@boolean@char@constant@date@datetime@dec@decimal@int@integer@money@number@numeric@nvarchar@real@simple_integer@smallint@time@tinyint@varchar@varchar2@varray@"; 1124 c_joinStr = "@left outer join@right outer join@full inner join@full outer join@inner join@outer join@left join@full join@right join@cross join@join@"; 1125 c_fromWhereMoreKeywordsStr = "@from@where@on@having@into@group by@sort by@order siblings by@order by@when matched@when not matched@using@"; 1126 c_sqlServerSPRelatedSqlStr1 = "@alter proc@alter procedure@close@commit@create procedure@deallocate@declare@drop procedure@exec@execute@go@goto@grant execute@if"; 1127 c_sqlServerSPRelatedSqlStr2 = "@loop@open@print@return@rollback transaction@while@begin catch@begin tran@begin transaction@begin try@else@end catch@end try@end@set@then@"; 1128 1129 c_noSpacesAroundBracket = "noSpacesAroundBracket"; 1130 c_oneSpaceInsideBracket = "oneSpaceInsideBracket"; 1131 c_oneSpaceOutsideBracket = "oneSpaceOutsideBracket"; 1132 c_oneSpaceAroundBracket = "oneSpaceAroundBracket"; 1133 c_noSpacesAroundComma = "noSpacesAroundComma"; 1134 c_oneSpaceAfterComma = "oneSpaceAfterComma"; 1135 c_oneSpaceBeforeComma = "oneSpaceBeforeComma"; 1136 c_oneSpaceAroundComma = "oneSpaceAroundComma"; 1137 c_noSpacesAroundEqual = "noSpacesAroundEqual"; 1138 c_oneSpaceAroundEqual = "oneSpaceAroundEqual"; 1139 c_unchangedSpaceInsideBracket = "unchangedSpaceInsideBracket"; 1140 c_unchangedSpaceComma = "unchangedSpaceComma"; 1141 c_unchangedEqualComma = "unchangedEqualComma"; 1142 1143 align_left = "L"; 1144 align_right = "R"; 1145 boolean_yes = "Y"; 1146 boolean_no = "N"; 1147 1148 c_all = "all"; 1149 c_alter_function = "alter function"; 1150 c_alter_proc = "alter proc"; 1151 c_alter_procedure = "alter procedure"; 1152 c_alter_table = "alter table"; 1153 c_alter_view = "alter view"; 1154 c_and = "and"; 1155 c_as = "as"; 1156 c_begin = "begin"; 1157 c_begin_catch = "begin catch"; 1158 c_begin_tran = "begin tran"; 1159 c_begin_transaction = "begin transaction"; 1160 c_begin_try = "begin try"; 1161 c_between = "between"; 1162 c_by = "by"; 1163 c_case = "case"; 1164 c_cast = "cast"; 1165 c_Close = "close"; 1166 c_collect = "collect"; 1167 c_commit = "commit"; 1168 c_concat = "concat"; 1169 c_connect_by = "connect by"; 1170 c_create = "create"; 1171 c_create_function = "create function"; 1172 c_create_proc = "create proc"; 1173 c_create_procedure = "create procedure"; 1174 c_create_synonym = "create synonym"; 1175 c_cross_apply = "cross apply"; 1176 c_cross_join = "cross join"; 1177 c_cube = "cube"; 1178 c_cursor = "cursor"; 1179 c_deallocate = "deallocate"; 1180 c_declare = "declare"; 1181 c_declare_global_temporary_table = "declare global temporary table"; 1182 c_decode = "decode"; 1183 c_del = "del"; 1184 c_delete = "delete"; 1185 c_drop_procedure = "drop procedure"; 1186 c_drop_table = "drop table"; 1187 c_else = "else"; 1188 c_elsif = "elsif"; 1189 c_elseif = "elseif"; 1190 c_end = "end"; 1191 c_end_catch = "end catch"; 1192 c_end_tran = "end tran"; 1193 c_end_transaction = "end transaction"; 1194 c_end_try = "end try"; 1195 c_exec = "exec"; 1196 c_execute = "execute"; 1197 c_except = "except"; 1198 c_exception = "exception"; 1199 c_exception_join = "exception join"; 1200 c_floor = "floor"; 1201 c_FIRST = "first"; 1202 c_for_delete = "for delete"; 1203 c_for_insert = "for insert"; 1204 c_for_update = "for update"; 1205 c_function = "function"; 1206 c_grant_execute = "grant execute"; 1207 c_group_by = "group by"; 1208 c_having = "having"; 1209 c_iif = "iif"; 1210 c_if = "if"; 1211 c_in = "in"; 1212 c_inner_join = "inner join"; 1213 c_inout = "inout"; 1214 c_ins = "ins"; 1215 c_insert = "insert"; 1216 c_insert_into = "insert into"; 1217 c_ins_into = "ins into"; 1218 c_intersect = "intersect"; 1219 c_into = "into"; 1220 c_is = "is"; 1221 c_is_distinct_from = "is distinct from"; 1222 c_is_not_distinct_from = "is not distinct from"; 1223 c_like = "like"; 1224 c_next = "next"; 1225 c_not = "not"; 1226 c_not_like = "not like"; 1227 c_null = "null"; 1228 c_is_not_null = "is not null"; 1229 c_is_null = "is null"; 1230 c_fetch = "fetch"; 1231 c_for = "for"; 1232 c_full_inner_join = "full inner join"; 1233 c_full_join = "full join"; 1234 c_full_outer_join = "full outer join"; 1235 c_function_header = "function header"; 1236 c_from = "from"; 1237 c_go = "go"; 1238 c_left_exception_join = "left exception join"; 1239 c_left_join = "left join"; 1240 c_left_outer_join = "left outer join"; 1241 c_limit = "limit"; 1242 c_locking = "locking"; 1243 c_loop = "loop"; 1244 c_minus = "minus"; 1245 c_member = "member"; 1246 c_merge = "merge"; 1247 c_object = "object"; 1248 c_offset = "offset"; 1249 c_on = "on"; 1250 c_open = "open"; 1251 c_openquery = "openquery"; 1252 c_out = "out";// 'out'; 1253 c_outer_apply = "outer apply";//'outer apply'; 1254 c_outer_join = "outer join";//'outer join'; 1255 c_or = "or";//'or'; 1256 c_order_by = "order by";//'order by'; 1257 c_order_siblings_by = "order siblings by";//'order siblings by'; 1258 c_package ="package";// 'package'; 1259 c_package_header = "package header";//'package header'; 1260 c_pause = "pause";//'pause'; 1261 c_print = "print";//'print'; 1262 c_pro = "pro";//'pro'; 1263 c_procedure = "procedure";//'procedure'; 1264 c_procedure_header = "procedure header";//'procedure header'; 1265 c_prompt = "prompt";//'prompt'; 1266 c_qualify = "qualify";//'qualify'; 1267 c_queryno = "queryno";//'queryno'; 1268 c_raiserror = "raiserror";//'raiserror'; 1269 c_record = "record";//'record'; 1270 c_rem = "rem";//'rem'; 1271 c_remark = "remark";//'remark'; 1272 c_repeat = "repeat";//'repeat'; 1273 c_return = "return";//'return'; 1274 c_returning = "returning";//'returning'; 1275 c_returns = "returns";//'returns'; 1276 c_right_exception_join = "right exception join";//'right exception join'; 1277 c_right_join = "right join";//'right join'; 1278 c_right_outer_join = "right outer join";//'right outer join'; 1279 c_rollback_transaction = "rollback transaction";//'rollback transaction'; 1280 c_rollup = "rollup";//'rollup'; 1281 c_run = "run";// 'run'; 1282 c_sel_all ="sel all";// 'sel all'; 1283 c_sel_distinct = "sel distinct";//'sel distinct'; 1284 c_select = "select";; 1285 c_sel = "sel";//'sel'; 1286 c_select_all = "select all";//'select all'; 1287 c_select_distinct = "select distinct";//'select distinct'; 1288 c_set = "set";//'set'; 1289 c_sort_by = "sort by";//'sort by'; 1290 c_sql = "SQL";//'SQL'; 1291 c_start_with = "start with";//'start with'; 1292 c_table = "table";//'table'; 1293 c_then = "then";//'then'; 1294 c_truncate_table = "truncate table";//'truncate table'; 1295 c_type = "type";//'type'; 1296 c_union = "union";//'union'; 1297 c_union_all = "union all";//'union all'; 1298 c_upd = "upd";//'upd'; 1299 c_update = "update";// 'update'; 1300 c_values = "values";//'values'; 1301 c_vb_string = "VB String(5)";//'VB String(5)'; 1302 c_when = "when";//'when'; 1303 c_when_matched = "when matched";// 'when matched'; 1304 c_when_not_matched = "when not matched";//'when not matched'; 1305 c_where = "where";//'where'; 1306 c_while = "while";//'while'; 1307 c_with = "with";//'with'; 1308 c_with_check = "with check";//'with check'; 1309 c_with_execute_as = "with execute as";//'with execute as'; 1310 1311 regex_number = "^[-+][0-9]+$ '^[-+][0-9]+$"; 1312 regex_float = "#[0-9]+.[0-9]+.[0-9]+#'#[0-9]+.[0-9]+.[0-9]+#"; 1313 regex_collect_stats_on = "collect +(stats|statistic) +on";//'collect +(stats|statistic) +on'; 1314 regex_create_or_replace_function = "create +(or +replace +)?function +\\w+";//'create +(or +replace +)?function +\w+'; 1315 regex_create_or_replace_function_mysql = "create +(or +replace +)?function";//'create +(or +replace +)?function'; 1316 regex_create_or_replace_package = "create +(or +replace +)?package +\\w+";//'create +(or +replace +)?package +\w+'; 1317 regex_create_or_replace_package_mysql = "create +(or +replace +)?package";//'create +(or +replace +)?package'; 1318 regex_create_or_replace_procedure = "create +(or +replace +)?procedure +\\w+";//'create +(or +replace +)?procedure +\w+'; 1319 regex_create_or_replace_procedure_mysql = "create +(or +replace +)?procedure";//'create +(or +replace +)?procedure'; 1320 regex_create_or_replace_view = "create +(or +replace +)?View";//'create +(or +replace +)?View'; 1321 regex_create_or_replace_synonym = "create +(or +replace +)?synonym +\\w+";//'create +(or +replace +)?synonym +\w+'; 1322 regex_create_or_replace_table = "create +(or +replace +)?Table";//'create +(or +replace +)?Table'; 1323 regex_create_global_temporary_table = "create +global +temporary +table";//'create +global +temporary +table'; 1324 regex_create_set_volatile_table = "create +(set +(volatile +)?|multiset +(volatile +)?)?Table";//'create +(set +(volatile +)?|multiset +(volatile +)?)?Table'; 1325 regex_create_set_global_temporary_table = "create +(set +(global temporary +)?|multiset +(global temporary +)?)?Table";//'create +(set +(global temporary +)?|multiset +(global temporary +)?)?Table'; 1326 regex_create_unique_index = "create +(unique +|clustered +|nonclustered +)?Index";//'create +(unique +|clustered +|nonclustered +)?Index'; 1327 regex_create_temporary_table_if_not_exists = "create +(temporary +)?table +(if +not +exists)?";//'create +(temporary +)?table +(if +not +exists)?'; 1328 regex_cursor_is = "cursor +\\w+ +is";//'cursor +\w+ +is'; 1329 regex_declare_cursor_for = "Declare *\\w+ *((insensitive|scroll) *)*cursor *for ";//'Declare *\w+ *((insensitive|scroll) *)*cursor *for'; 1330 regex_declare_cursor_for2 = "Declare *\\w+ *cursor *((LOCAL|GLOBAL) *)*((FORWARD_ONLY|SCROLL) *)*((STATIC|KEYSET|DYNAMIC|FAST_FORWARD) *)*((READ_ONLY|SCROLL_LOCKS|OPTIMISTIC) *)*((TYPE_WARNING) *)*for ";// 'Declare *\w+ *cursor *((LOCAL|GLOBAL) *)*((FORWARD_ONLY|SCROLL) *)*((STATIC|KEYSET|DYNAMIC|FAST_FORWARD) *)*((READ_ONLY|SCROLL_LOCKS|OPTIMISTIC) *)*((TYPE_WARNING) *)*for'; 1331 regex_declare_global_temporary_table ="declare +global +temporary +table";// 'declare +global +temporary +table'; 1332 regex_declare_table = "declare +@\\w+ +Table";//'declare +@\w+ +Table'; 1333 regex_drop_table_if_not_exists = "drop +(temporary +)?table +(if +exists)?";//'drop +(temporary +)?table +(if +exists)?'; 1334 regex_exec = "(EXEC|EXECUTE) +\"?([a-zA-Z0-9_$%@#&\247\"\\[\\]])+(\\.+([a-zA-Z0-9_$%@#&\247\"\\[\\]])+)*\"?$";//'(EXEC|EXECUTE) +\"?([a-zA-Z0-9_$%@#&\247\"\[\]])+(\.+([a-zA-Z0-9_$%@#&\247\"\[\]])+)*\"?$"; 1335 regex_locking_table = "LOCKING +TABLE";//'LOCKING +TABLE'; 1336 regex_open_cursor_for = "open +\\w+ +cursor +for ";//'open +\w+ +cursor +for'; 1337 regex_returns_table = "returns +@\\w+ +Table'returns +@\\w+ +Table"; 1338 regex_select_top_with = "select +top *(\\( *)?\\w+ *(\\) *)?(percent *)?(with ties)? ";//'select +top *(\( *)?\w+ *(\) *)?(percent *)?(with ties)?'; 1339 regex_with_nolock_rowlock_tablock = "with +(\\( *nolock *\\)|\\( *rowlock *\\)|\\( *tablock *\\))";//'with +(\( *nolock *\)|\( *rowlock *\)|\( *tablock *\))'; 1340 regex_with_execute_as = "with +EXECUTE +AS";//'with +EXECUTE +AS'; 1341 regex_with_cte = "With +\\w+ *\\( *\\w+ *(, *\\w+ *)*\\) ";//'With +\w+ *\( *\w+ *(, *\w+ *)*\)'; 1342 regex_w = "\\w:";//'\w:'; 1343 1344 1345 // regex_patternBn = '^"?([a-zA-Z0-9_$%@#&247"\[\]])+(\.+([a-zA-Z0-9_$%@#&247"\[\]])+)*"?$'; 1346 PatternBn = "^\"?([a-zA-Z0-9_$%@#&247\"\\[\\]])+(\\.+([a-zA-Z0-9_$%@#&247\"\\[\\]])+)*\"?$"; 1347 1348 1349 bq = true; 1350 MAX_ALIGN_TOKENS = 16; 1351 bz = 103; 1352 PRE_LOCATED_LINES = 200; 1353 NUMBER_OF_WHITESPACE = 200; 1354 colorByte = 4; 1355 1356 indentOfEachlineWithPaddingSpace = new int[PRE_LOCATED_LINES]; 1357 indentOfEachline = new int[PRE_LOCATED_LINES]; 1358 dR = new int[PRE_LOCATED_LINES]; 1359 1360 bX = new StringBuilder(); 1361 solidTokenSB = new StringBuilder(); 1362 formattedSQL = new StringBuilder(); 1363 1364 functionList = new ArrayList<>(); 1365 1366 1367 functionStr = c_functionStr1+c_functionStr2+c_functionStr3; 1368 1369 sqlplusStr = c_sqlplusStr1+c_sqlplusStr2; 1370 1371 datatypeStr = c_datatypeStr;//'@%rowtype@%type@bigint@binary@bit@boolean@char@constant@date@datetime@dec@decimal@int@integer@money@number@numeric@nvarchar@real@simple_integer@smallint@time@tinyint@varchar@varchar2@varray@'; 1372 joinStr = c_joinStr;//'@left outer join@right outer join@full inner join@full outer join@inner join@outer join@left join@full join@right join@cross join@join@'; 1373 fromWhereMoreKeywordsStr = c_fromWhereMoreKeywordsStr;//'@from@where@on@having@into@group by@sort by@order siblings by@order by@when matched@when not matched@using@'; 1374 sqlServerSPRelatedSqlStr = c_sqlServerSPRelatedSqlStr1+c_sqlServerSPRelatedSqlStr2;//'@alter proc@alter procedure@close@commit@create procedure@deallocate@declare@drop procedure@exec@execute@go@goto@grant execute@if' 1375 // +'@loop@open@print@return@rollback transaction@while@begin catch@begin tran@begin transaction@begin try@else@end catch@end try@end@set@then@'; 1376 1377 1378 1379 spaceArray = new String[NUMBER_OF_WHITESPACE + 1]; 1380 tokenToAlign = new String[MAX_ALIGN_TOKENS + 1][bz]; 1381 posOfTokenToAlign = new int[MAX_ALIGN_TOKENS + 1][bz]; 1382 lineOfTokenToAlign = new int[MAX_ALIGN_TOKENS + 1][bz]; 1383 columnPosOfTokenToAlign = new int[MAX_ALIGN_TOKENS + 1][bz]; 1384 numsOfTokenAbleToAlign = new short[MAX_ALIGN_TOKENS + 1][bz]; 1385 bracketLevelOfTokenToAlign = new short[MAX_ALIGN_TOKENS + 1][bz]; 1386 numsOfTokenToAlign = new int[MAX_ALIGN_TOKENS + 1]; 1387 1388 // Define line separator based on the operating system 1389 lineSeparator = System.getProperty("line.separator"); 1390 1391 colorRelatedB2 = 8; 1392 1393 neverExpired = false; 1394 colorRelatedB1 = false; 1395 bQ1 = false; 1396 1397 initFormatOptions(vendor, option); 1398 1399 } 1400 1401 1402 public int resetBlockIDToSameBracketsLevelNotStartWithMasterKey(int pBlockID) { 1403 boolean flag = false; 1404 short bracketLevelOfBlock = bracketsInBlock[pBlockID]; 1405 int blockID = pBlockID; 1406 while (blockID >= 0 && !flag) { 1407 if (bracketsInBlock[blockID] == bracketLevelOfBlock && !brStartWithMasterKey[blockID]) { 1408 flag = true; 1409 } else { 1410 blockID--; 1411 } 1412 } 1413 return blockID; 1414 } 1415 1416 public void synchronizeTokenBlockID() { 1417 int i1 = 0; 1418 int j1 = 0; 1419 boolean flag = false; 1420 tmpK = 1; 1421 while (tmpK <= sqlTokenLen) { 1422 if (tokenArray[tmpK].length() == 0) { 1423 tmpK = skipToNonEmptyToken(tmpK + 1); 1424 } 1425 if (IsStartOfaSQL[tmpK]) { 1426 flag = false; 1427 } 1428 if (flag && blockIDByToken[tmpK] == j1) { 1429 blockIDByToken[tmpK] = i1; 1430 } 1431 if (!IsEndOfCompleteSQL[tmpK]) { 1432 tmpK++; 1433 continue; 1434 } 1435 flag = true; 1436 j1 = blockIDByToken[skipToNextNonEmptyToken(tmpK)]; 1437 if (!myequals(tokenArray[tmpK], c_char_right_paren)) { 1438 j1 = blockIDByToken[skipToNextNonEmptyToken(tmpK)]; 1439 i1 = resetBlockIDToSameBracketsLevelNotStartWithMasterKey(blockIDByToken[tmpK]); 1440 } else { 1441 i1 = resetBlockIDToSameBracketsLevelNotStartWithMasterKey( 1442 blockIDByToken[skipToNextNonEmptyToken(tmpK)]); 1443 } 1444 tmpK++; 1445 } 1446 } 1447 1448 public void setSQLBlock() { 1449 short currentBracketLevel = 0; 1450 int numOfComment = 0; 1451 int accumulateBlockID = 0; 1452 int tokenBlockID = 0; 1453 boolean leftBracketBeforeMasterKey = false; 1454 1455 brStartToken[0] = 0; 1456 tmpK = 0; 1457 blockIDByToken[tmpK] = 0; 1458 initBlockRelatedArray(0); 1459 tmpK = 1; 1460 1461 while (tmpK <= sqlTokenLen) { 1462 if (tokenArray[tmpK].length() == 0) { 1463 tmpK = skipToNonEmptyToken(tmpK + 1); 1464 } 1465 1466 blockIDByToken[tmpK] = tokenBlockID; 1467 1468 if (myequals(tokenArray[tmpK], c_char_left_paren) && !IsInNonFormatZone[tmpK]) { 1469 if (startTokenOfMasterSQL[posOfNextToken_nocomment_noempty_noleftbracket(tmpK)]) { 1470 leftBracketBeforeMasterKey = true; 1471 } 1472 accumulateBlockID++; 1473 currentBracketLevel++; 1474 tokenBlockID = accumulateBlockID; 1475 blockIDByToken[tmpK] = tokenBlockID; 1476 initBlockRelatedArray(tokenBlockID); 1477 bracketsInBlock[tokenBlockID] = currentBracketLevel; 1478 brStartToken[accumulateBlockID] = tmpK; 1479 } 1480 1481 if (startTokenOfMasterSQL[tmpK] && !myequals(prevToken_nonComment_noEmpty(tmpK), c_char_left_paren)) { 1482 accumulateBlockID++; 1483 tokenBlockID = accumulateBlockID; 1484 blockIDByToken[tmpK] = tokenBlockID; 1485 initBlockRelatedArray(tokenBlockID); 1486 brStartWithMasterKey[tokenBlockID] = true; 1487 bracketsInBlock[tokenBlockID] = currentBracketLevel; 1488 brStartToken[accumulateBlockID] = tmpK; 1489 } 1490 1491 if (IsStartComment[tmpK] && ((tNbrOfPrecedingLinebreak[tmpK] > 0) || (tmpK == 1)) && (numOfComment == 0) 1492 && startTokenOfMasterSQL[posOfNextToken_nocomment_noempty_noleftbracket(tmpK)] 1493 && !leftBracketBeforeMasterKey) { 1494 numOfComment++; 1495 tokenBlockID = accumulateBlockID + 1; 1496 blockIDByToken[tmpK] = tokenBlockID; 1497 } 1498 1499 if (startTokenOfMasterSQL[tmpK] && !IsInNonFormatZone[tmpK]) { 1500 leftBracketBeforeMasterKey = false; 1501 numOfComment = 0; 1502 } 1503 1504 if (!myequals(tokenArray[tmpK], c_char_right_paren) || IsInNonFormatZone[tmpK]) { 1505 tmpK++; 1506 continue; 1507 } 1508 1509 currentBracketLevel--; 1510 if (currentBracketLevel < 0) { 1511 currentBracketLevel = 0; 1512 } 1513 1514 if (brStartWithMasterKey[tokenBlockID]) { 1515 tokenBlockID = resetBlockIDToSameBracketsLevelNotStartWithMasterKey(tokenBlockID); 1516 blockIDByToken[tmpK] = tokenBlockID; 1517 } 1518 1519 int k1 = tokenBlockID; 1520 boolean isPrevLevel = false; 1521 if (k1 > 0) { 1522 int word2 = bracketsInBlock[k1]; 1523 while (k1 > 0 && !isPrevLevel) { 1524 if (bracketsInBlock[k1] == word2 - 1) { 1525 isPrevLevel = true; 1526 } else { 1527 k1--; 1528 } 1529 } 1530 } else { 1531 k1 = 0; 1532 } 1533 tokenBlockID = k1; 1534 1535 tmpK++; 1536 } 1537 } 1538 1539 public void changePrecedingBlankFrom0to1() { 1540 tmpK = 1; 1541 while (tmpK <= sqlTokenLen) { 1542 if (tokenArray[tmpK].length() == 0) { 1543 tmpK = skipToNonEmptyToken(tmpK + 1); 1544 } 1545 if ((!IsInNonFormatZone[tmpK] || IsStartComment[tmpK] || IsStartDoubleQuotes[tmpK] || tNbrStartBlock[tmpK] 1546 || IsStartLiteral[tmpK]) && tNbrOfPrecedingLinebreak[tmpK] > 0 1547 && tNbrOfPrecedingBlanks[tmpK] == 0) { 1548 tNbrOfPrecedingBlanks[tmpK] = 1; 1549 } 1550 tmpK++; 1551 } 1552 } 1553 1554 public void calculateSQLLen() { 1555 tmpK = 1; 1556 while (tmpK <= sqlTokenLen) { 1557 if (tokenArray[tmpK].length() == 0) { 1558 tmpK = skipToNonEmptyToken(tmpK + 1); 1559 } 1560 int word0 = SQLIDByToken[tmpK]; 1561 if (IsStartOfaSQL[tmpK]) { 1562 SQLLength[word0] = 0; 1563 } 1564 if (IsInaSQL[tmpK]) { 1565 SQLLength[word0] += tokenArray[tmpK].length() + tNbrOfPrecedingBlanks[tmpK]; 1566 } 1567 if (!IsEndOfaSQL[tmpK]) { 1568 tmpK++; 1569 continue; 1570 } 1571 boolean flag1 = false; 1572 int i1 = word0 - 1; 1573 while (i1 > 0 && !flag1) { 1574 if (bracketsInSQL[i1] < bracketsInSQL[word0]) { 1575 flag1 = true; 1576 SQLLength[i1] += SQLLength[word0]; 1577 } 1578 i1--; 1579 } 1580 tmpK++; 1581 } 1582 1583 tmpK = 1; 1584 while (tmpK <= sqlTokenLen) { 1585 if (tokenArray[tmpK].length() == 0) { 1586 tmpK = skipToNonEmptyToken(tmpK + 1); 1587 } 1588 IsInSmallSQL[tmpK] = false; 1589 if (IsInaSQL[tmpK] && SQLLength[SQLIDByToken[tmpK]] < smallSQLLen) { 1590 IsInSmallSQL[tmpK] = true; 1591 tNbrcY[tmpK] = IsStartOfaSQL[tmpK]; 1592 tNbrck[tmpK] = IsEndOfaSQL[tmpK]; 1593 } 1594 tmpK++; 1595 } 1596 } 1597 1598 public void combineSomeKeywordIntoOne() { 1599 int tmpK = 1; 1600 String s1, s2, s3; 1601 1602 while (tmpK <= sqlTokenLen) { 1603 if (tokenArray[tmpK].length() == 0) { 1604 tmpK = skipToNonEmptyToken(tmpK + 1); 1605 } 1606 if (IsInNonFormatZone[tmpK]) { 1607 tmpK++; 1608 continue; 1609 } 1610 if (equalsIgnoreCase(tokenArray[tmpK], c_with)) { 1611 if (matchByPatternYieldString(regex_with_nolock_rowlock_tablock, true, tmpK, 3, c_numberOfSpace_m1)) { 1612 tokenArray[tmpK] = patternMatchedString; 1613 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(tmpK), 3); 1614 } 1615 if ((dbname == EDbVendor.dbvmssql) 1616 && matchByPatternYieldString(regex_with_execute_as, true, tmpK, 2, c_numberOfSpace_n)) { 1617 tokenArray[tmpK] = patternMatchedString; 1618 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(tmpK), 2); 1619 } 1620 } 1621 if ((dbname == EDbVendor.dbvdb2) && equalsIgnoreCase(tokenArray[tmpK], c_is)) { 1622 s1 = tokenArray[tmpK] + concatTokens(tmpK, 2, c_numberOfSpace_1); 1623 if (equalsIgnoreCase(s1, c_is_distinct_from)) { 1624 tokenArray[tmpK] = s1; 1625 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(tmpK), 2); 1626 } 1627 s1 = tokenArray[tmpK] + concatTokens(tmpK, 3, c_numberOfSpace_1); 1628 if (equalsIgnoreCase(s1, c_is_not_distinct_from)) { 1629 tokenArray[tmpK] = s1; 1630 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(tmpK), 3); 1631 } 1632 } 1633 if (equalsIgnoreCase(tokenArray[tmpK], c_when)) { 1634 s2 = tokenArray[tmpK] + concatTokens(tmpK, 1, c_numberOfSpace_1); 1635 if (equalsIgnoreCase(s2, c_when_matched)) { 1636 tokenArray[tmpK] = s2; 1637 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(tmpK), 1); 1638 } 1639 s2 = tokenArray[tmpK] + concatTokens(tmpK, 2, c_numberOfSpace_1); 1640 if (equalsIgnoreCase(s2, c_when_not_matched)) { 1641 tokenArray[tmpK] = s2; 1642 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(tmpK), 2); 1643 } 1644 } 1645 s3 = tokenArray[tmpK] + concatTokens(tmpK, 2, c_numberOfSpace_1); 1646 if ((equalsIgnoreCase(s3, c_left_outer_join) || equalsIgnoreCase(s3, c_right_outer_join) 1647 || equalsIgnoreCase(s3, c_right_exception_join)) && (dbname == EDbVendor.dbvdb2) 1648 || equalsIgnoreCase(s3, c_left_exception_join) && (dbname == EDbVendor.dbvdb2) 1649 || equalsIgnoreCase(s3, c_full_inner_join) || equalsIgnoreCase(s3, c_full_outer_join) 1650 || equalsIgnoreCase(s3, c_order_siblings_by) && (dbname == EDbVendor.dbvoracle) 1651 || equalsIgnoreCase(s3, c_is_not_null)) { 1652 tokenArray[tmpK] = s3; 1653 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(tmpK), 2); 1654 } 1655 s3 = tokenArray[tmpK] + concatTokens(tmpK, 1, c_numberOfSpace_1); 1656 if (equalsIgnoreCase(s3, c_inner_join) || equalsIgnoreCase(s3, c_outer_join) 1657 || equalsIgnoreCase(s3, c_exception_join) && (dbname == EDbVendor.dbvdb2) 1658 || equalsIgnoreCase(s3, c_full_join) || equalsIgnoreCase(s3, c_left_join) 1659 || equalsIgnoreCase(s3, c_right_join) 1660 || equalsIgnoreCase(s3, c_cross_apply) && (dbname == EDbVendor.dbvmssql) 1661 || equalsIgnoreCase(s3, c_outer_apply) && (dbname == EDbVendor.dbvmssql) 1662 || equalsIgnoreCase(s3, c_grant_execute) && (dbname == EDbVendor.dbvmssql) 1663 || equalsIgnoreCase(s3, c_order_by) || equalsIgnoreCase(s3, c_sort_by) 1664 || equalsIgnoreCase(s3, c_group_by) || equalsIgnoreCase(s3, c_union_all) 1665 || equalsIgnoreCase(s3, c_cross_join) || equalsIgnoreCase(s3, c_insert_into) 1666 || equalsIgnoreCase(s3, c_ins_into) && (dbname == EDbVendor.dbvteradata) 1667 || equalsIgnoreCase(s3, c_select_distinct) || equalsIgnoreCase(s3, c_select_all) 1668 || equalsIgnoreCase(s3, c_sel_distinct) && (dbname == EDbVendor.dbvteradata) 1669 || equalsIgnoreCase(s3, c_sel_all) && (dbname == EDbVendor.dbvteradata) 1670 || equalsIgnoreCase(s3, c_alter_table) || equalsIgnoreCase(s3, c_alter_view) 1671 || equalsIgnoreCase(s3, c_truncate_table) 1672 || equalsIgnoreCase(s3, c_drop_table) && !(dbname == EDbVendor.dbvmysql) 1673 || equalsIgnoreCase(s3, c_for_insert) || equalsIgnoreCase(s3, c_for_update) 1674 || equalsIgnoreCase(s3, c_for_delete) 1675 || equalsIgnoreCase(s3, c_create_procedure) && (dbname == EDbVendor.dbvmssql) 1676 || equalsIgnoreCase(s3, c_create_proc) && (dbname == EDbVendor.dbvmssql) 1677 || equalsIgnoreCase(s3, c_alter_procedure) && (dbname == EDbVendor.dbvmssql) 1678 || equalsIgnoreCase(s3, c_alter_proc) && (dbname == EDbVendor.dbvmssql) 1679 || equalsIgnoreCase(s3, c_drop_procedure) 1680 || equalsIgnoreCase(s3, c_create_function) && (dbname == EDbVendor.dbvmssql) 1681 || equalsIgnoreCase(s3, c_alter_function) && (dbname == EDbVendor.dbvmssql) 1682 || equalsIgnoreCase(s3, c_start_with) && (dbname == EDbVendor.dbvoracle) 1683 || equalsIgnoreCase(s3, c_connect_by) && (dbname == EDbVendor.dbvoracle) 1684 || equalsIgnoreCase(s3, c_is_null) || equalsIgnoreCase(s3, c_not_like) 1685 || equalsIgnoreCase(s3, c_rollback_transaction) || equalsIgnoreCase(s3, c_begin_catch) 1686 || equalsIgnoreCase(s3, c_end_catch) || equalsIgnoreCase(s3, c_begin_tran) 1687 || equalsIgnoreCase(s3, c_begin_try) || equalsIgnoreCase(s3, c_end_try) 1688 || equalsIgnoreCase(s3, c_begin_transaction) || equalsIgnoreCase(s3, c_with_check)) { 1689 tokenArray[tmpK] = s3; 1690 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(tmpK), 1); 1691 } 1692 tmpK++; 1693 } 1694 } 1695 1696 public void concateSpecialChar() { 1697 int tmpK, nextToken, j1; 1698 tmpK = 1; 1699 1700 while (tmpK < sqlTokenLen) { 1701 1702 if (tokenArray[tmpK].length() == 0) { 1703 tmpK = skipToNonEmptyToken(tmpK + 1); 1704 } 1705 nextToken = skipToNextNonEmptyToken(tmpK); 1706 if (!IsInLiteral[tmpK] && equalsToChar(tokenArray[tmpK], '\t')) { 1707 tNbrOfPrecedingBlanks[nextToken] += tNbrOfPrecedingBlanks[tmpK] + 1; 1708 tNbrOfPrecedingLinebreak[nextToken] += tNbrOfPrecedingLinebreak[tmpK]; 1709 setToEmptyTokenInThisRange(tmpK, 1); 1710 } 1711 if (!IsInNonFormatZone[tmpK] && dbname == EDbVendor.dbvoracle && endsWith(tokenArray[tmpK], c_char_percent) 1712 && tNbrOfPrecedingBlanks[nextToken] > 0) { 1713 // Your logic here for Oracle 1714 } 1715 1716 if (IsInNonFormatZone[tmpK] || tNbrOfPrecedingBlanks[nextToken] != 0) { 1717 tmpK++; 1718 continue; 1719 } 1720 1721 if ((equalsToChar(tokenArray[tmpK], '-') && equalsToChar(tokenArray[nextToken], '-')) 1722 || equalsToChar(tokenArray[tmpK], ':') 1723 || (equalsToChar(tokenArray[tmpK], '*') && equalsToChar(tokenArray[nextToken], '=')) 1724 || (equalsToChar(tokenArray[tmpK], '*') && equalsToChar(tokenArray[nextToken], '*')) 1725 || (equalsToChar(tokenArray[tmpK], '!') && equalsToChar(tokenArray[nextToken], '=')) 1726 || (equalsToChar(tokenArray[tmpK], '<') && equalsToChar(tokenArray[nextToken], '>')) 1727 || (equalsToChar(tokenArray[tmpK], '(') && equalsToChar(tokenArray[nextToken], ')')) 1728 || (equalsToChar(tokenArray[tmpK], '=') && equalsToChar(tokenArray[nextToken], '*')) 1729 || (equalsToChar(tokenArray[tmpK], '|') && equalsToChar(tokenArray[nextToken], '|')) 1730 || (equalsToChar(tokenArray[tmpK], '=') && equalsToChar(tokenArray[nextToken], '>')) 1731 || (equalsToChar(tokenArray[tmpK], '>') && equalsToChar(tokenArray[nextToken], '=')) 1732 || (equalsToChar(tokenArray[tmpK], '<') && equalsToChar(tokenArray[nextToken], '=')) 1733 || (equalsToChar(tokenArray[tmpK], (char) 254) && equalsToChar(tokenArray[nextToken], '=')) 1734 || (equalsToChar(tokenArray[tmpK], '<') && equalsToChar(tokenArray[nextToken], '<')) 1735 || (equalsToChar(tokenArray[tmpK], '>') && equalsToChar(tokenArray[nextToken], '>')) 1736 || (equalsToChar(tokenArray[tmpK], '-') && equalsToChar(tokenArray[nextToken], '>')) 1737 || (endsWith(tokenArray[tmpK], ".") && equalsToChar(tokenArray[nextToken], '*')) 1738 || matchByPattern(regex_number, false, tmpK, 1, c_numberOfSpace_n)) { 1739 tokenArray[tmpK] += tokenArray[nextToken]; 1740 setToEmptyTokenInThisRange(nextToken, 1); 1741 } else if ((tmpK < sqlTokenLen - 1) && equalsToChar(tokenArray[tmpK], '(') 1742 && equalsToChar(tokenArray[nextToken], '+') 1743 && equalsToChar(tokenArray[next2SolidToken(tmpK)], ')')) { 1744 tokenArray[tmpK] += tokenArray[nextToken] + tokenArray[next2SolidToken(tmpK)]; 1745 setToEmptyTokenInThisRange(nextToken, 2); 1746 } else if ((tmpK < sqlTokenLen - 1) && equalsToChar(tokenArray[tmpK], '(') 1747 && equalsToChar(tokenArray[nextToken], '*') 1748 && equalsToChar(tokenArray[next2SolidToken(tmpK)], ')')) { 1749 tokenArray[tmpK] += tokenArray[nextToken] + tokenArray[next2SolidToken(tmpK)]; 1750 setToEmptyTokenInThisRange(nextToken, 2); 1751 } else if ((tmpK < sqlTokenLen - 1) && equalsToChar(tokenArray[tmpK], '=') 1752 && equalsToChar(tokenArray[nextToken], ':') && (tNbrOfPrecedingBlanks[nextToken] == 0) 1753 && (tNbrOfPrecedingBlanks[next2SolidToken(tmpK)] > 0)) { 1754 tokenArray[tmpK] += tokenArray[nextToken] + tokenArray[next2SolidToken(tmpK)]; 1755 setToEmptyTokenInThisRange(nextToken, 2); 1756 } else if ((dbname == EDbVendor.dbvaccess) && startsWith(tokenArray[tmpK], "#") && (tmpK < sqlTokenLen) 1757 && matchByPatternYieldString(regex_float, true, tmpK, 4, c_numberOfSpace_n)) { 1758 tokenArray[tmpK] = patternMatchedString; 1759 setToEmptyTokenInThisRange(tmpK + 1, 4); 1760 } 1761 if (!((tmpK < sqlTokenLen - 1) && startsWith(tokenArray[tmpK], ":")) 1762 || (!equalsToChar(tokenArray[skipToNextNonEmptyToken(tmpK)], '-') 1763 || (tNbrOfPrecedingBlanks[skipToNextNonEmptyToken(tmpK)] != 0))) { 1764 tmpK++; 1765 continue; 1766 } 1767 1768 j1 = skipToNextNonEmptyToken(tmpK); 1769 while (equalsToChar(tokenArray[j1], '-') && (tNbrOfPrecedingBlanks[j1] == 0) 1770 && (tNbrOfPrecedingBlanks[skipToNextNonEmptyToken(j1)] == 0) && (j1 < sqlTokenLen)) { 1771 tokenArray[tmpK] += tokenArray[j1] + tokenArray[skipToNextNonEmptyToken(j1)]; 1772 setToEmptyTokenInThisRange(j1, 1); 1773 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(j1), 1); 1774 j1 = skipToNextNonEmptyToken(tmpK); 1775 } 1776 1777 tmpK++; 1778 } 1779 } 1780 1781 public String concatTokens(int startPos, int len, String numberOfSpace) { 1782 String s2 = ""; 1783 int k1 = 0; 1784 posOfSearchedToken = startPos; 1785 while (true) { 1786 if ((posOfSearchedToken > sqlTokenLen) || (k1 >= len)) { 1787 break; 1788 } 1789 posOfSearchedToken++; 1790 if (!(tokenArray[posOfSearchedToken].length() == 0)) { 1791 if (equalsToChar(numberOfSpace, c_numberOfSpace_1)) { 1792 s2 += " "; 1793 } 1794 if (equalsToChar(numberOfSpace, c_numberOfSpace_n)) { 1795 s2 += spaceArray[Math.min(NUMBER_OF_WHITESPACE, tNbrOfPrecedingBlanks[posOfSearchedToken])]; 1796 } 1797 if (equalsIgnoreCase(numberOfSpace, c_numberOfSpace_m1)) { 1798 s2 += spaceArray[Math.min(1, tNbrOfPrecedingBlanks[posOfSearchedToken])]; 1799 } 1800 s2 += tokenArray[posOfSearchedToken]; 1801 k1++; 1802 } 1803 } 1804 return s2; 1805 } 1806 1807 public void detectAlias() { 1808 int tmpK = 1; 1809 while (tmpK <= sqlTokenLen) { 1810 if (tokenArray[tmpK].length() == 0) { 1811 tmpK = skipToNonEmptyToken(tmpK + 1); 1812 } 1813 if (tNbrcF[tmpK] && !IsInNonFormatZone[tmpK] && !IsStartSELECTList[tmpK] 1814 && isValidIdentifier(tokenArray[tmpK], true) 1815 && (!IsStartSELECTList[prevToken_nonComment_noEmpty_returnPos(tmpK)] 1816 && !myequals(tokenArray[prevToken_nonComment_noEmpty_returnPos(tmpK)], c_char_coma) 1817 && (myequals(tokenArray[posOfNextToken_nonComment_nonEmpty(tmpK)], c_char_coma) 1818 || IsEndSELECTList[tmpK]) 1819 || equalsIgnoreCase(tokenArray[prevToken_nonComment_noEmpty_returnPos(tmpK)], c_as))) { 1820 IsAlias[tmpK] = true; 1821 } 1822 tmpK++; 1823 } 1824 } 1825 1826 public void detectColumn() { 1827 int tmpK = 1; 1828 while (tmpK <= sqlTokenLen) { 1829 if (tokenArray[tmpK].length() == 0) { 1830 tmpK = skipToNonEmptyToken(tmpK + 1); 1831 } 1832 if (IsInSELECTList[tmpK] && !IsAlias[tmpK] && isValidIdentifier(tokenArray[tmpK], true) 1833 && !isFunction(tokenArray[tmpK], functionList) 1834 && !includeStr(c_char_at + tokenArray[tmpK] + c_char_at, tokenSeparator) 1835 && !includeStr(c_char_at + tokenArray[tmpK] + c_char_at, caseCustomizedKeywords) 1836 && !includeStr(c_char_at + tokenArray[tmpK] + c_char_at, caseCustomizedVariableType)) { 1837 IsColumn[tmpK] = true; 1838 } 1839 tmpK++; 1840 } 1841 } 1842 1843 public void setKeyword1() { 1844 tNbrKeyword1[tmpK] = true; 1845 prevKeyword1 = currentKeyword1; 1846 currentKeyword1 = tokenArray[tmpK]; 1847 } 1848 1849 public void setTrueCanGetLineBreakAfter() { 1850 CanSetLineBreakAfter[tmpK] = true; 1851 } 1852 1853 public void setFalseCanGetLineBreakAfter() { 1854 CanSetLineBreakAfter[tmpK] = false; 1855 } 1856 1857 public String unknownMethod1(int i1) { 1858 String s1 = ""; 1859 boolean flag = false; 1860 posOfSearchedToken = i1; 1861 while (true) { 1862 if ((posOfSearchedToken > sqlTokenLen) || flag) { 1863 break; 1864 } 1865 posOfSearchedToken++; 1866 if (!(tokenArray[posOfSearchedToken].length() == 0)) { 1867 if (tNbrOfPrecedingBlanks[posOfSearchedToken] == 0) { 1868 s1 = tokenArray[posOfSearchedToken]; 1869 } else { 1870 s1 = ""; 1871 } 1872 flag = true; 1873 } 1874 } 1875 return s1; 1876 } 1877 1878 public void setSPKeyword(String s1) { 1879 if (sqlserverb1) { 1880 reducedLevel = 1; 1881 } 1882 sqlserverMasterKeyRelatedBoolean = false; 1883 sqlserverb1 = false; 1884 tNbrdl[tmpK] = true; 1885 BelongsToSPKeyword[tmpK] = s1; 1886 } 1887 1888 public String unknownMethod2(int i1) { 1889 String s1 = ""; 1890 boolean flag = false; 1891 posOfSearchedToken = i1; 1892 if (tNbrOfPrecedingBlanks[posOfSearchedToken] > 0) { 1893 s1 = ""; 1894 flag = true; 1895 } 1896 1897 while (true) { 1898 if ((posOfSearchedToken <= 1) || flag) { 1899 break; 1900 } 1901 posOfSearchedToken--; 1902 if (!(tokenArray[posOfSearchedToken].length() == 0)) { 1903 s1 = tokenArray[posOfSearchedToken]; 1904 flag = true; 1905 } 1906 } 1907 return s1; 1908 } 1909 1910 public void doFormatSpace() { 1911 if (removeUnnecessayWhiteSpaces) { 1912 tNbrOfPrecedingBlanks[1] = 0; 1913 } 1914 1915 tmpK = 1; 1916 while (tmpK <= sqlTokenLen) { 1917 if (tokenArray[tmpK].length() == 0) { 1918 tmpK = skipToNonEmptyToken(tmpK + 1); 1919 } 1920 int i1 = skipToNextNonEmptyToken(tmpK); 1921 if (IsInNonFormatZone[tmpK] && !tNbrStartBlock[tmpK] && !IsStartLiteral[tmpK] && !IsStartComment[tmpK] 1922 && !IsStartDoubleQuotes[tmpK]) { 1923 tmpK++; 1924 continue; 1925 } 1926 if (removeUnnecessayWhiteSpaces && tNbrOfPrecedingBlanks[tmpK] > 1) { 1927 tNbrOfPrecedingBlanks[tmpK] = 1; 1928 } 1929 if (equalsIgnoreCase(spaceAroundBracketOption, c_noSpacesAroundBracket)) { 1930 if (equalsIgnoreCase(tokenArray[tmpK], c_char_left_paren)) { 1931 tNbrOfPrecedingBlanks[i1] = 0; 1932 tNbrOfPrecedingBlanks[tmpK] = 0; 1933 } 1934 if (equalsIgnoreCase(tokenArray[tmpK], c_char_right_paren)) { 1935 tNbrOfPrecedingBlanks[i1] = 1; 1936 tNbrOfPrecedingBlanks[tmpK] = 0; 1937 } 1938 } 1939 if (equalsIgnoreCase(spaceAroundBracketOption, c_oneSpaceInsideBracket)) { 1940 if (equalsIgnoreCase(tokenArray[tmpK], c_char_left_paren)) { 1941 tNbrOfPrecedingBlanks[i1] = 1; 1942 tNbrOfPrecedingBlanks[tmpK] = 0; 1943 } 1944 if (equalsIgnoreCase(tokenArray[tmpK], c_char_right_paren)) { 1945 tNbrOfPrecedingBlanks[tmpK] = 1; 1946 } 1947 } 1948 if (equalsIgnoreCase(spaceAroundBracketOption, c_oneSpaceOutsideBracket)) { 1949 if (equalsIgnoreCase(tokenArray[tmpK], c_char_left_paren)) { 1950 tNbrOfPrecedingBlanks[i1] = 0; 1951 tNbrOfPrecedingBlanks[tmpK] = 1; 1952 } 1953 if (equalsIgnoreCase(tokenArray[tmpK], c_char_right_paren)) { 1954 tNbrOfPrecedingBlanks[tmpK] = 0; 1955 tNbrOfPrecedingBlanks[i1] = 1; 1956 } 1957 } 1958 if (equalsIgnoreCase(spaceAroundBracketOption, c_oneSpaceAroundBracket) 1959 && (equalsIgnoreCase(tokenArray[tmpK], c_char_left_paren) 1960 || equalsIgnoreCase(tokenArray[tmpK], c_char_right_paren))) { 1961 tNbrOfPrecedingBlanks[i1] = 1; 1962 tNbrOfPrecedingBlanks[tmpK] = 1; 1963 } 1964 if (equalsIgnoreCase(tokenArray[tmpK], c_char_coma)) { 1965 if (equalsIgnoreCase(spaceAroundCommaOption, c_noSpacesAroundComma)) { 1966 tNbrOfPrecedingBlanks[i1] = 0; 1967 tNbrOfPrecedingBlanks[tmpK] = 0; 1968 } 1969 if (equalsIgnoreCase(spaceAroundCommaOption, c_oneSpaceAfterComma)) { 1970 tNbrOfPrecedingBlanks[i1] = 1; 1971 tNbrOfPrecedingBlanks[tmpK] = 0; 1972 } 1973 if (equalsIgnoreCase(spaceAroundCommaOption, c_oneSpaceBeforeComma)) { 1974 tNbrOfPrecedingBlanks[i1] = 0; 1975 tNbrOfPrecedingBlanks[tmpK] = 1; 1976 } 1977 if (equalsIgnoreCase(spaceAroundCommaOption, c_oneSpaceAroundComma)) { 1978 tNbrOfPrecedingBlanks[i1] = 1; 1979 tNbrOfPrecedingBlanks[tmpK] = 1; 1980 } 1981 } 1982 if (!equalsIgnoreCase(tokenArray[tmpK], c_char_equal) && !equalsIgnoreCase(tokenArray[tmpK], c_char_great) 1983 && !equalsIgnoreCase(tokenArray[tmpK], c_char_less) 1984 && !equalsIgnoreCase(tokenArray[tmpK], c_char_less + c_char_equal) 1985 && !equalsIgnoreCase(tokenArray[tmpK], c_char_great + c_char_equal) 1986 && !equalsIgnoreCase(tokenArray[tmpK], c_char_colon + c_char_equal) 1987 && !equalsIgnoreCase(tokenArray[tmpK], c_char_exclamation + c_char_equal) 1988 && !equalsIgnoreCase(tokenArray[tmpK], c_char_less + c_char_great) 1989 && !equalsIgnoreCase(tokenArray[tmpK], c_char_equal + c_char_star) 1990 && !equalsIgnoreCase(tokenArray[tmpK], c_char_colon + c_char_equal) 1991 && !equalsIgnoreCase(tokenArray[tmpK], c_char_equal + c_char_colon) 1992 && !equalsIgnoreCase(tokenArray[tmpK], c_char_star + c_char_equal) 1993 && !equalsIgnoreCase(tokenArray[tmpK], c_char_plus) 1994 && !equalsIgnoreCase(tokenArray[tmpK], c_char_minus) 1995 && !equalsIgnoreCase(tokenArray[tmpK], c_char_star) 1996 && !equalsIgnoreCase(tokenArray[tmpK], c_char_divide)) { 1997 tmpK++; 1998 continue; 1999 } 2000 if (equalsIgnoreCase(spaceAroundOperatorOption, c_noSpacesAroundEqual)) { 2001 tNbrOfPrecedingBlanks[i1] = 0; 2002 tNbrOfPrecedingBlanks[tmpK] = 0; 2003 } 2004 if (equalsIgnoreCase(spaceAroundOperatorOption, c_oneSpaceAroundEqual)) { 2005 tNbrOfPrecedingBlanks[i1] = 1; 2006 tNbrOfPrecedingBlanks[tmpK] = 1; 2007 } 2008 2009 tmpK++; 2010 } 2011 } 2012 2013 public void findMasterSQL() { 2014 int masterKeyCount = 0; 2015 int tmpK = 1; 2016 2017 while (tmpK <= sqlTokenLen) { 2018 if (tokenArray[tmpK].length() == 0) { 2019 tmpK = skipToNonEmptyToken(tmpK + 1); 2020 } 2021 if (IsInNonFormatZone[tmpK]) { 2022 tmpK++; 2023 continue; 2024 } 2025 int currentPos = tmpK; 2026 String currentToken = tokenArray[tmpK]; 2027 boolean isMasterKey = false; 2028 2029 if (equalsIgnoreCase(currentToken, c_with)) { // CTE 2030 if (matchByPattern(regex_with_cte, true, currentPos, 24, c_numberOfSpace_1)) { 2031 isMasterKey = true; 2032 } 2033 } 2034 2035 boolean setflag = true; 2036 if (!isSelectToken(currentToken) && !equalsIgnoreCase(currentToken, c_select_distinct) 2037 && !equalsIgnoreCase(currentToken, c_select_all) && !isUpdateToken(currentToken) 2038 && !equalsIgnoreCase(currentToken, c_intersect) && !equalsIgnoreCase(currentToken, c_except) 2039 && !equalsIgnoreCase(currentToken, c_minus) && !equalsIgnoreCase(currentToken, c_union) 2040 && !equalsIgnoreCase(currentToken, c_union_all) && !isInsertToken(currentToken) 2041 && !equalsIgnoreCase(currentToken, c_insert_into) && !equalsIgnoreCase(currentToken, c_ins_into)) { 2042 String s2 = currentToken; 2043 boolean flag1 = false; 2044 if (equalsIgnoreCase(s2, c_delete) 2045 || (equalsIgnoreCase(s2, c_del) && (dbname.equals(EDbVendor.dbvteradata)))) { 2046 flag1 = true; 2047 } 2048 if (!flag1 && !equalsIgnoreCase(currentToken, c_merge) && !equalsIgnoreCase(currentToken, c_fetch) 2049 && !equalsIgnoreCase(currentToken, c_alter_table) 2050 && !equalsIgnoreCase(currentToken, c_alter_view) 2051 && !equalsIgnoreCase(currentToken, c_drop_table) 2052 && !equalsIgnoreCase(currentToken, c_truncate_table) 2053 && (!equalsIgnoreCase(currentToken, c_openquery) || !dbname.equals(EDbVendor.dbvmssql))) { 2054 setflag = false; 2055 } 2056 } 2057 if (setflag) { 2058 isMasterKey = true; 2059 } 2060 2061 if (!isMasterKey && equalsIgnoreCase(currentToken, c_declare)) { 2062 if (matchByPatternYieldStringAndTokenNum(regex_declare_global_temporary_table, true, currentPos, 3, 2063 "1")) { 2064 tokenArray[currentPos] = patternMatchedString; 2065 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2066 isMasterKey = true; 2067 } 2068 } 2069 2070 if (!isMasterKey && dbname.equals(EDbVendor.dbvmssql)) { 2071 if (matchByPatternYieldStringAndTokenNum(regex_declare_table, true, currentPos, 2, c_numberOfSpace_1)) { 2072 tokenArray[currentPos] = patternMatchedString; 2073 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2074 isMasterKey = true; 2075 } 2076 } 2077 2078 if (!isMasterKey && equalsIgnoreCase(currentToken, c_collect) && dbname.equals(EDbVendor.dbvteradata)) { 2079 if (matchByPatternYieldStringAndTokenNum(regex_collect_stats_on, true, currentPos, 2, 2080 c_numberOfSpace_1)) { 2081 tokenArray[currentPos] = patternMatchedString; 2082 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2083 isMasterKey = true; 2084 } 2085 } 2086 2087 if (!isMasterKey && equalsIgnoreCase(currentToken, c_locking) && dbname.equals(EDbVendor.dbvteradata)) { 2088 if (matchByPatternYieldStringAndTokenNum(regex_locking_table, true, currentPos, 1, c_numberOfSpace_1)) { 2089 tokenArray[currentPos] = patternMatchedString; 2090 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2091 isMasterKey = true; 2092 } 2093 } 2094 2095 if (equalsIgnoreCase(currentToken, c_returns) && dbname.equals(EDbVendor.dbvmssql) && !isMasterKey) { 2096 if (matchByPatternYieldStringAndTokenNum(regex_returns_table, true, currentPos, 2, c_numberOfSpace_1)) { 2097 tokenArray[currentPos] = patternMatchedString; 2098 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2099 isMasterKey = true; 2100 } 2101 } 2102 2103 if (equalsIgnoreCase(currentToken, c_create)) { 2104 if (!isMasterKey) { 2105 if (matchByPatternYieldStringAndTokenNum(regex_create_or_replace_view, true, currentPos, 3, 2106 c_numberOfSpace_1)) { 2107 tokenArray[currentPos] = patternMatchedString; 2108 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2109 isMasterKey = true; 2110 } 2111 } 2112 if (!isMasterKey) { 2113 if (matchByPatternYieldStringAndTokenNum(regex_create_or_replace_table, true, currentPos, 3, 2114 c_numberOfSpace_1)) { 2115 tokenArray[currentPos] = patternMatchedString; 2116 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2117 isMasterKey = true; 2118 } 2119 } 2120 if (!isMasterKey) { 2121 if (matchByPatternYieldStringAndTokenNum(regex_create_global_temporary_table, true, currentPos, 3, 2122 c_numberOfSpace_1)) { 2123 tokenArray[currentPos] = patternMatchedString; 2124 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2125 isMasterKey = true; 2126 } 2127 } 2128 if (!isMasterKey && dbname.equals(EDbVendor.dbvteradata)) { 2129 if (matchByPatternYieldStringAndTokenNum(regex_create_set_volatile_table, true, currentPos, 3, 2130 c_numberOfSpace_1)) { 2131 tokenArray[currentPos] = patternMatchedString; 2132 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2133 isMasterKey = true; 2134 } else if (matchByPatternYieldStringAndTokenNum(regex_create_set_global_temporary_table, true, 2135 currentPos, 4, c_numberOfSpace_1)) { 2136 tokenArray[currentPos] = patternMatchedString; 2137 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2138 isMasterKey = true; 2139 } 2140 } 2141 if (!isMasterKey) { 2142 if (matchByPatternYieldStringAndTokenNum(regex_create_unique_index, true, currentPos, 2, 2143 c_numberOfSpace_1)) { 2144 tokenArray[currentPos] = patternMatchedString; 2145 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2146 isMasterKey = true; 2147 } 2148 } 2149 if (!isMasterKey && dbname.equals(EDbVendor.dbvmysql)) { 2150 if (matchByPatternYieldStringAndTokenNum(regex_create_temporary_table_if_not_exists, true, 2151 currentPos, 5, c_numberOfSpace_1)) { 2152 tokenArray[currentPos] = patternMatchedString; 2153 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2154 isMasterKey = true; 2155 } 2156 } 2157 } 2158 if (!isMasterKey && dbname.equals(EDbVendor.dbvmysql)) { 2159 if (matchByPatternYieldStringAndTokenNum(regex_drop_table_if_not_exists, true, currentPos, 4, 2160 c_numberOfSpace_1)) { 2161 tokenArray[currentPos] = patternMatchedString; 2162 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(currentPos), patternMatchedTokenNum - 1); 2163 isMasterKey = true; 2164 } 2165 } 2166 2167 if (isMasterKey) { 2168 startTokenOfMasterSQL[tmpK] = true; 2169 masterKeyCount++; 2170 } 2171 2172 tmpK++; 2173 } 2174 2175 numberOfStatementPlus10 = masterKeyCount + 10; 2176 } 2177 2178 public void myStrToStrings(String S, String Sep, List<String> List, boolean AllowEmptyString) { 2179// assert List != null; 2180// List.clear(); 2181// int L = Sep.length(); 2182// int I = S.indexOf(Sep); 2183// while (I > 0) { 2184// String Left = S.substring(0, I - 1); 2185// if (!Left.isEmpty() || AllowEmptyString) { 2186// List.add(Left); 2187// } 2188// S = S.substring(I + L - 1); 2189// I = S.indexOf(Sep); 2190// } 2191// if (!S.isEmpty()) { 2192// List.add(S); 2193// } 2194 2195 List.addAll(Arrays.asList(S.split(Sep))); 2196 2197 } 2198 2199 public void formatsqltext(String sqltext) { 2200 inputSQLText = sqltext; 2201 2202 if (dbname.equals(EDbVendor.dbvoracle)) { 2203 fromWhereMoreKeywordsStr += c_returning + c_char_at; 2204 } 2205 2206 if (dbname.equals(EDbVendor.dbvteradata)) { 2207 fromWhereMoreKeywordsStr += c_qualify + c_char_at; 2208 } 2209 2210 if (dbname.equals(EDbVendor.dbvmssql)) { 2211 joinStr += c_cross_apply + c_char_at + c_outer_apply + c_char_at; 2212 functionStr += c_floor + c_char_at; 2213 } 2214 2215 if (dbname.equals(EDbVendor.dbvdb2)) { 2216 fromWhereMoreKeywordsStr += c_queryno + c_char_at; 2217 joinStr += c_exception_join + c_char_at + c_left_exception_join + c_char_at + c_right_exception_join 2218 + c_char_at; 2219 } 2220 2221 if (dbname.equals(EDbVendor.dbvmysql)) { 2222 fromWhereMoreKeywordsStr += c_limit + c_char_at + c_offset + c_char_at; 2223 } 2224 2225 if (dbname.equals(EDbVendor.dbvpostgresql)) { 2226 fromWhereMoreKeywordsStr += c_limit + c_char_at + c_offset + c_char_at; 2227 } 2228 2229 output_start_line = ""; 2230 output_start_of_each_line = ""; 2231 output_end_of_each_line = lineSeparator; 2232 output_end_line = ""; 2233 2234 if (dbname.equals(EDbVendor.dbvteradata)) { 2235 myStrToStrings(TeradataFunctions, "@", functionList, false); 2236 } else { 2237 myStrToStrings(commonFunctions, "@", functionList, false); 2238 } 2239 Collections.sort(functionList); 2240 2241 datatypeStr += caseCustomizedVariableType; 2242 2243 hostVariableRelatedCount = 0; 2244 bN = ""; 2245 spaceArray[0] = ""; 2246 2247 for (int i = 1; i < NUMBER_OF_WHITESPACE; i++) { 2248 spaceArray[i] = spaceArray[i - 1] + " "; 2249 } 2250 2251 bX.setLength(0); 2252 solidTokenSB.setLength(0); 2253 formattedSQL.setLength(0); 2254 2255 tokenSeparator = ""; 2256 for (int i = 0; i < tokenSeparatorArray.length; i++) { 2257 tokenSeparator += tokenSeparatorArray[i]; 2258 } 2259 2260 sqlTokens = new StringTokenizer(inputSQLText, tokenSeparator, true); 2261 2262 initTokenArray(); 2263 mergeSignOfComment(); 2264 mergeEscapeChar(); 2265 initArrayIndexByToken(); 2266 setNonFormatZone(); 2267 if (dbname.equals(EDbVendor.dbvmssql)) { 2268 setNonFormatZoneSQLServer(); 2269 } 2270 2271 changePrecedingBlankFrom0to1(); 2272 concateSpecialChar(); 2273 combineSomeKeywordIntoOne(); 2274 findMasterSQL(); 2275 2276 numberOfLeftBracket += numberOfStatementPlus10 + 10; 2277 bracketsInBlock = new short[numberOfLeftBracket]; 2278 brPrimaryIndent = new short[numberOfLeftBracket]; 2279 brSetPrimaryIndentToCursorPosition = new boolean[numberOfLeftBracket]; 2280 brSurroundsParams = new boolean[numberOfLeftBracket]; 2281 brPrimaryIndentBeforBr = new short[numberOfLeftBracket]; 2282 brdz = new short[numberOfLeftBracket]; 2283 blockIsSQL = new boolean[numberOfLeftBracket]; 2284 brStartWithMasterKey = new boolean[numberOfLeftBracket]; 2285 brSurroundsSQL = new boolean[numberOfLeftBracket]; 2286 brSurroundsCondition = new boolean[numberOfLeftBracket]; 2287 brSurroundsCase = new boolean[numberOfLeftBracket]; 2288 brAfterSQLMasterKeyword = new boolean[numberOfLeftBracket]; 2289 brAfterInsertValuesKeyword = new boolean[numberOfLeftBracket]; 2290 brWithCommaLineBreak = new boolean[numberOfLeftBracket]; 2291 brPrecedingT = new String[numberOfLeftBracket]; 2292 brSQLMasterKeyword = new String[numberOfLeftBracket]; 2293 brStartToken = new int[numberOfLeftBracket]; 2294 2295 mergeLiteralIntoOneToken(); 2296 mergeQualifiedIdentifier(); 2297 setSQLBlock(); 2298 if (isRemoveUnnecessaryBracket) { 2299 removeUnnecessaryBracket(); 2300 } 2301 setPrecedingTokenOfLeftBracket_masterkey(); 2302 setBlockRelatedArray(); 2303 initStatementRelatedArray(); 2304 SQLLevelAndScope(); 2305 doFormatSpace(); 2306 synchronizeTokenBlockID(); 2307 resetSomeBracketArrayIfNotInASQL(); 2308 setJoinScope(); 2309 selectStatementClauseScope(); 2310 detectAlias(); 2311 detectColumn(); 2312 calculateSQLLen(); 2313 if (IsInaSQL[tmpK]) { 2314 setCaseSegment(); 2315 } else { 2316 processCaseRelated2(); 2317 } 2318 formatLinebreak(); 2319 2320 sqlTokens = null; 2321 } 2322 2323 public int getLastNoBracketnoCommentPos(int i1) { 2324 prevToken_nonComment_nonEmpty_nonLeftBracket(i1); 2325 return posOfSearchedToken; 2326 } 2327 2328 public void initBlockRelatedArray(int i1) { 2329 bracketsInBlock[i1] = 0; 2330 brPrimaryIndent[i1] = 0; 2331 brSetPrimaryIndentToCursorPosition[i1] = false; 2332 brSurroundsParams[i1] = false; 2333 brPrimaryIndentBeforBr[i1] = 0; 2334 brdz[i1] = 0; 2335 blockIsSQL[i1] = false; 2336 brStartWithMasterKey[i1] = false; 2337 brSurroundsSQL[i1] = false; 2338 brSurroundsCondition[i1] = false; 2339 brSurroundsCase[i1] = false; 2340 brAfterSQLMasterKeyword[i1] = false; 2341 brAfterInsertValuesKeyword[i1] = false; 2342 brWithCommaLineBreak[i1] = false; 2343 brPrecedingT[i1] = ""; 2344 brSQLMasterKeyword[i1] = ""; 2345 brStartToken[i1] = 0; 2346 } 2347 2348 public void initStatementRelatedArray() { 2349 SQLLength = new int[numberOfStatementPlus10]; 2350 bracketsInSQL = new short[numberOfStatementPlus10]; 2351 SQLStartsAtT = new int[numberOfStatementPlus10]; 2352 SQLEndsAtT = new int[numberOfStatementPlus10]; 2353 SQLPrimaryIndent = new short[numberOfStatementPlus10]; 2354 longestMasterKeywordsInSQL = new short[numberOfStatementPlus10]; 2355 SQLStartWithBracket = new boolean[numberOfStatementPlus10]; 2356 SQLStartWithComment = new boolean[numberOfStatementPlus10]; 2357 SQLbL = new boolean[numberOfStatementPlus10]; 2358 SQLIsSubSQL = new boolean[numberOfStatementPlus10]; 2359 2360 for (int i1 = 0; i1 < numberOfStatementPlus10; i1++) { 2361 SQLStartWithBracket[i1] = false; 2362 SQLStartWithComment[i1] = false; 2363 SQLbL[i1] = false; 2364 SQLIsSubSQL[i1] = false; 2365 bracketsInSQL[i1] = 0; 2366 SQLStartsAtT[i1] = 0; 2367 SQLEndsAtT[i1] = sqlTokenLen; 2368 SQLPrimaryIndent[i1] = 0; 2369 longestMasterKeywordsInSQL[i1] = 0; 2370 SQLLength[i1] = 0; 2371 } 2372 } 2373 2374 public void initTokenArray() { 2375 String s2 = ""; 2376 int continuouslySpace = 0; 2377 short continuouslyLinebreak = 0; 2378 int k1 = 0; 2379 boolean notFromProgram = !SQLFromProgram; 2380 2381 int tokenNum = sqlTokens.countTokens(); 2382 int tokenNumPlus2 = tokenNum + 2; 2383 2384 tokenArray = new String[tokenNumPlus2]; 2385 tNbrOfPrecedingBlanks = new int[tokenNumPlus2]; 2386 tNbrOfPrecedingBlanks2 = new int[tokenNumPlus2]; 2387 tNbrOfPrecedingLinebreak = new short[tokenNumPlus2]; 2388 tNbrOfPrecedingLinebreakOutputSQL = new short[tokenNumPlus2]; 2389 IsEndBlock = new boolean[tokenNumPlus2]; 2390 IsEndCase = new boolean[tokenNumPlus2]; 2391 IsEndDoubleQuotes = new boolean[tokenNumPlus2]; 2392 IsEndComment = new boolean[tokenNumPlus2]; 2393 isEndLineComment = new boolean[tokenNumPlus2]; 2394 isEndBlockComment = new boolean[tokenNumPlus2]; 2395 IsEndLiteral = new boolean[tokenNumPlus2]; 2396 IsEndFrozenZone = new boolean[tokenNumPlus2]; 2397 IsEndOfCompleteSQL = new boolean[tokenNumPlus2]; 2398 IsEndOfaSQL = new boolean[tokenNumPlus2]; 2399 tNbrck = new boolean[tokenNumPlus2]; 2400 IsEndSELECTList = new boolean[tokenNumPlus2]; 2401 IsEndJOIN = new boolean[tokenNumPlus2]; 2402 IsEndJOIN_ON = new boolean[tokenNumPlus2]; 2403 IsEndFROM = new boolean[tokenNumPlus2]; 2404 IsEndWHERE = new boolean[tokenNumPlus2]; 2405 IsEndGROUPBY = new boolean[tokenNumPlus2]; 2406 IsEndORDERBY = new boolean[tokenNumPlus2]; 2407 tNbrcs = new boolean[tokenNumPlus2]; 2408 tNbrInBlock = new boolean[tokenNumPlus2]; 2409 IsInCase = new boolean[tokenNumPlus2]; 2410 tNbrInDoubleQuotes = new boolean[tokenNumPlus2]; 2411 IsInComment = new boolean[tokenNumPlus2]; 2412 isInlineComment = new boolean[tokenNumPlus2]; 2413 IsInLiteral = new boolean[tokenNumPlus2]; 2414 IsInFrozenZone = new boolean[tokenNumPlus2]; 2415 IsInNonFormatZone = new boolean[tokenNumPlus2]; 2416 isInBlockComment = new boolean[tokenNumPlus2]; 2417 tNbrcC = new boolean[tokenNumPlus2]; 2418 IsInaSQL = new boolean[tokenNumPlus2]; 2419 IsInSmallSQL = new boolean[tokenNumPlus2]; 2420 tNbrcF = new boolean[tokenNumPlus2]; 2421 IsInSELECTList = new boolean[tokenNumPlus2]; 2422 IsInJOIN = new boolean[tokenNumPlus2]; 2423 IsInJOIN_ON = new boolean[tokenNumPlus2]; 2424 IsInFROM = new boolean[tokenNumPlus2]; 2425 IsInWHERE = new boolean[tokenNumPlus2]; 2426 IsInGROUPBY = new boolean[tokenNumPlus2]; 2427 IsInORDERBY = new boolean[tokenNumPlus2]; 2428 tNbrcN = new boolean[tokenNumPlus2]; 2429 tNbrKeyword1 = new boolean[tokenNumPlus2]; 2430 tNbrStartBlock = new boolean[tokenNumPlus2]; 2431 IsStartCase = new boolean[tokenNumPlus2]; 2432 IsStartDoubleQuotes = new boolean[tokenNumPlus2]; 2433 IsStartComment = new boolean[tokenNumPlus2]; 2434 isStartLineComment = new boolean[tokenNumPlus2]; 2435 isStartBlockComment = new boolean[tokenNumPlus2]; 2436 IsStartLiteral = new boolean[tokenNumPlus2]; 2437 IsStartFrozenZone = new boolean[tokenNumPlus2]; 2438 IsStartOfaSQL = new boolean[tokenNumPlus2]; 2439 tNbrcY = new boolean[tokenNumPlus2]; 2440 IsStartSELECTList = new boolean[tokenNumPlus2]; 2441 IsAlias = new boolean[tokenNumPlus2]; 2442 IsColumn = new boolean[tokenNumPlus2]; 2443 IsStartJOIN = new boolean[tokenNumPlus2]; 2444 IsStartJOIN_ON = new boolean[tokenNumPlus2]; 2445 IsStartFROM = new boolean[tokenNumPlus2]; 2446 IsStartWHERE = new boolean[tokenNumPlus2]; 2447 IsStartGROUPBY = new boolean[tokenNumPlus2]; 2448 IsStartORDERBY = new boolean[tokenNumPlus2]; 2449 tNbrda = new boolean[tokenNumPlus2]; 2450 blockIDByToken = new int[tokenNumPlus2]; 2451 SQLIDByToken = new short[tokenNumPlus2]; 2452 tNbrdl = new boolean[tokenNumPlus2]; 2453 CanSetLineBreakAfter = new boolean[tokenNumPlus2]; 2454 tNbrdn = new boolean[tokenNumPlus2]; 2455 startTokenOfMasterSQL = new boolean[tokenNumPlus2]; 2456 BelongsToSPKeyword = new String[tokenNumPlus2]; 2457 tNbrProcessThisToken = new boolean[tokenNumPlus2]; 2458 tNbrColorRelated = new byte[tokenNumPlus2]; 2459 2460 tokenArray[0] = ""; 2461 tNbrOfPrecedingBlanks[0] = 0; 2462 tNbrOfPrecedingBlanks2[0] = 0; 2463 tNbrOfPrecedingLinebreak[0] = 0; 2464 tmpK = 1; 2465 2466 while (true) { 2467 if (!sqlTokens.hasMoreTokens()) { 2468 break; 2469 } 2470 String currentToken = sqlTokens.nextToken(); 2471 2472 if (notFromProgram) { 2473 if (currentToken.equals(String.valueOf(SPACE)) || currentToken.equals(String.valueOf(FORM_FEED)) || currentToken.equals(String.valueOf(BACKSPACE))) { 2474 continuouslySpace++; 2475 } else if (currentToken.equals(String.valueOf(CARRIAGE_RETURN))) { 2476 if (!lineSeparator.equals(String.valueOf(CARRIAGE_RETURN))) { 2477 continue; 2478 } 2479 continuouslyLinebreak++; 2480 continuouslySpace = 0; 2481 } else if (currentToken.equals(String.valueOf(LINE_FEED))) { 2482 continuouslyLinebreak++; 2483 continuouslySpace = 0; 2484 } else if (SQLFromProgram && currentToken.equalsIgnoreCase(charEncloseSQL) && !s2.equals(String.valueOf(BACKSLASH))) { 2485 notFromProgram = false; 2486 continuouslyLinebreak++; 2487 continuouslySpace = 0; 2488 } else { 2489 tokenArray[tmpK] = currentToken; 2490 tNbrOfPrecedingBlanks2[tmpK] = continuouslySpace; 2491 tNbrOfPrecedingBlanks[tmpK] = continuouslySpace; 2492 tNbrOfPrecedingLinebreak[tmpK] = continuouslyLinebreak; 2493 solidTokenSB.append(tokenArray[tmpK]); 2494 if (tokenArray[tmpK].equals(String.valueOf(LEFT_PARENTHESIS))) { 2495 k1++; 2496 } 2497 isFunction(tokenArray[tmpK], functionList); 2498 continuouslySpace = 0; 2499 continuouslyLinebreak = 0; 2500 tmpK++; 2501 } 2502 } else if (currentToken.equalsIgnoreCase(charEncloseSQL)) { 2503 notFromProgram = true; 2504 } 2505 2506 s2 = currentToken; 2507 } 2508 2509 if (tmpK > tokenNum) { 2510 sqlTokenLen = tokenNum; 2511 } else { 2512 sqlTokenLen = tmpK - 1; 2513 } 2514 2515 if (keepFirstLineIndent) { 2516 additionalIndent = tNbrOfPrecedingBlanks[1]; 2517 } 2518 2519 tokenArray[sqlTokenLen + 1] = ""; 2520 tNbrOfPrecedingBlanks[sqlTokenLen + 1] = 0; 2521 tNbrOfPrecedingBlanks2[sqlTokenLen + 1] = 0; 2522 tNbrOfPrecedingLinebreak[sqlTokenLen + 1] = 0; 2523 solidTokenStr = solidTokenSB.toString(); 2524 numberOfLeftBracket = k1; 2525 } 2526 2527 public void initArrayIndexByToken() { 2528 tmpK = 0; 2529 while (tmpK <= sqlTokenLen) { 2530 IsEndBlock[tmpK] = false; 2531 IsEndCase[tmpK] = false; 2532 IsEndDoubleQuotes[tmpK] = false; 2533 IsEndComment[tmpK] = false; 2534 isEndBlockComment[tmpK] = false; 2535 isEndLineComment[tmpK] = false; 2536 IsEndLiteral[tmpK] = false; 2537 IsEndFrozenZone[tmpK] = false; 2538 IsEndOfaSQL[tmpK] = false; 2539 IsEndOfCompleteSQL[tmpK] = false; 2540 tNbrck[tmpK] = false; 2541 IsEndSELECTList[tmpK] = false; 2542 IsEndJOIN[tmpK] = false; 2543 IsEndJOIN_ON[tmpK] = false; 2544 IsEndFROM[tmpK] = false; 2545 IsEndWHERE[tmpK] = false; 2546 IsEndGROUPBY[tmpK] = false; 2547 IsEndORDERBY[tmpK] = false; 2548 tNbrcs[tmpK] = false; 2549 tNbrInBlock[tmpK] = false; 2550 IsInCase[tmpK] = false; 2551 tNbrInDoubleQuotes[tmpK] = false; 2552 IsInComment[tmpK] = false; 2553 isInlineComment[tmpK] = false; 2554 IsInLiteral[tmpK] = false; 2555 IsInFrozenZone[tmpK] = false; 2556 IsInNonFormatZone[tmpK] = false; 2557 isInBlockComment[tmpK] = false; 2558 tNbrcC[tmpK] = false; 2559 IsInaSQL[tmpK] = false; 2560 IsInSmallSQL[tmpK] = false; 2561 tNbrcF[tmpK] = false; 2562 IsInSELECTList[tmpK] = false; 2563 IsInJOIN[tmpK] = false; 2564 IsInJOIN_ON[tmpK] = false; 2565 IsInFROM[tmpK] = false; 2566 IsInWHERE[tmpK] = false; 2567 IsInGROUPBY[tmpK] = false; 2568 IsInORDERBY[tmpK] = false; 2569 tNbrcN[tmpK] = false; 2570 tNbrStartBlock[tmpK] = false; 2571 IsStartCase[tmpK] = false; 2572 IsStartDoubleQuotes[tmpK] = false; 2573 IsStartComment[tmpK] = false; 2574 isStartBlockComment[tmpK] = false; 2575 isStartLineComment[tmpK] = false; 2576 IsStartLiteral[tmpK] = false; 2577 IsStartFrozenZone[tmpK] = false; 2578 IsStartOfaSQL[tmpK] = false; 2579 tNbrcY[tmpK] = false; 2580 IsStartSELECTList[tmpK] = false; 2581 tNbrda[tmpK] = false; 2582 IsAlias[tmpK] = false; 2583 IsColumn[tmpK] = false; 2584 IsStartJOIN[tmpK] = false; 2585 IsStartJOIN_ON[tmpK] = false; 2586 IsStartFROM[tmpK] = false; 2587 IsStartWHERE[tmpK] = false; 2588 tNbrdl[tmpK] = false; 2589 tNbrKeyword1[tmpK] = false; 2590 CanSetLineBreakAfter[tmpK] = false; 2591 tNbrdn[tmpK] = false; 2592 startTokenOfMasterSQL[tmpK] = false; 2593 tNbrColorRelated[tmpK] = 4; 2594 blockIDByToken[tmpK] = 0; 2595 SQLIDByToken[tmpK] = 0; 2596 tNbrOfPrecedingLinebreakOutputSQL[tmpK] = 0; 2597 BelongsToSPKeyword[tmpK] = ""; 2598 tmpK++; 2599 } 2600 } 2601 2602 public boolean isFunction(String s1, ArrayList<String> functionList) { 2603 return functionList.contains(s1); 2604 } 2605 2606 public boolean isInsertToken(String s1) { 2607 boolean result = false; 2608 if (equalsIgnoreCase(s1, c_insert) || (equalsIgnoreCase(s1, c_ins) && dbname.equals(EDbVendor.dbvteradata))) { 2609 result = true; 2610 } 2611 return result; 2612 } 2613 2614 public boolean isSelectToken(String s1) { 2615 boolean result = false; 2616 if (s1.equalsIgnoreCase(c_select) || (s1.equalsIgnoreCase(c_sel) && dbname.equals(EDbVendor.dbvteradata))) { 2617 result = true; 2618 } 2619 return result; 2620 } 2621 2622 public boolean isUpdateToken(String s1) { 2623 boolean result = false; 2624 if (s1.equalsIgnoreCase(c_update) || (s1.equalsIgnoreCase(c_upd) && dbname.equals(EDbVendor.dbvteradata))) { 2625 result = true; 2626 } 2627 return result; 2628 } 2629 2630 public void setNonFormatZone() { 2631 String s1 = " "; 2632 String s2 = " "; 2633 int i1 = 0; 2634 inComment1 = false; 2635 2636 tmpK = 1; 2637 2638 while (tmpK <= sqlTokenLen) { 2639 if (tokenArray[tmpK].length() == 0) { 2640 tmpK = skipToNonEmptyToken(tmpK + 1); 2641 } 2642 2643 int prevToken = posOfPrevToken_nonEmpty(tmpK); 2644 int nextToken = skipToNextNonEmptyToken(tmpK); 2645 2646 if (IsInNonFormatZone[prevToken] && (!IsEndBlock[prevToken]) && (!IsEndComment[prevToken]) 2647 && (!IsEndLiteral[prevToken]) && (!IsEndDoubleQuotes[prevToken])) { 2648 IsInNonFormatZone[tmpK] = true; 2649 } 2650 2651 if (enableNonFormat) { 2652 if (IsInFrozenZone[prevToken] && (!IsEndFrozenZone[prevToken])) { 2653 IsInFrozenZone[tmpK] = true; 2654 if (myequals(tokenArray[tmpK], nonFormatEndTag) && equalsIgnoreCase(tokenArray[prevToken], "--")) { 2655 IsEndFrozenZone[tmpK] = true; 2656 } 2657 } 2658 if ((!IsInNonFormatZone[tmpK]) && myequals(tokenArray[tmpK], "--") 2659 && myequals(tokenArray[nextToken], nonFormatStartTag)) { 2660 IsInFrozenZone[tmpK] = true; 2661 IsStartFrozenZone[tmpK] = true; 2662 } 2663 if ((tmpK >= sqlTokenLen) || (nextToken > sqlTokenLen)) { 2664 IsEndFrozenZone[tmpK] = true; 2665 } 2666 } 2667 2668 if (IsInComment[prevToken] && (!IsEndComment[prevToken])) { 2669 IsInComment[tmpK] = true; 2670 IsInNonFormatZone[tmpK] = true; 2671 if (isInlineComment[prevToken]) { 2672 isInlineComment[tmpK] = true; 2673 } 2674 if (isInBlockComment[prevToken]) { 2675 isInBlockComment[tmpK] = true; 2676 } 2677 if (isInlineComment[tmpK] && (tNbrOfPrecedingLinebreak[nextToken] > 0)) { 2678 isEndLineComment[tmpK] = true; 2679 IsEndComment[tmpK] = true; 2680 } 2681 if (isInBlockComment[tmpK] && (myequals(tokenArray[tmpK], "*/"))) { 2682 IsEndComment[tmpK] = true; 2683 isEndBlockComment[tmpK] = true; 2684 } 2685 } 2686 2687 if (!IsInNonFormatZone[tmpK]) { 2688 if (startsWith(tokenArray[tmpK], "--") || equalsIgnoreCase(tokenArray[tmpK], "//") 2689 || (dbname.equals(EDbVendor.dbvoracle)) && (tNbrOfPrecedingLinebreak[tmpK] > 0) 2690 && (equalsIgnoreCase(tokenArray[tmpK], c_rem) 2691 || equalsIgnoreCase(tokenArray[tmpK], c_remark) 2692 || equalsIgnoreCase(tokenArray[tmpK], c_prompt) 2693 || equalsIgnoreCase(tokenArray[tmpK], c_pro) 2694 || equalsIgnoreCase(tokenArray[tmpK], c_pause))) { 2695 IsInComment[tmpK] = true; 2696 isInlineComment[tmpK] = true; 2697 IsStartComment[tmpK] = true; 2698 isStartLineComment[tmpK] = true; 2699 } 2700 if (myequals(tokenArray[tmpK], "/*")) { 2701 IsInComment[tmpK] = true; 2702 isInBlockComment[tmpK] = true; 2703 IsStartComment[tmpK] = true; 2704 isStartBlockComment[tmpK] = true; 2705 } 2706 if (isInlineComment[tmpK] && (tNbrOfPrecedingLinebreak[nextToken] > 0)) { 2707 isEndLineComment[tmpK] = true; 2708 IsEndComment[tmpK] = true; 2709 } 2710 } 2711 2712 if (isStartLineComment[tmpK] && isInlineComment[tmpK] && (tNbrOfPrecedingLinebreak[nextToken] > 0)) { 2713 isEndLineComment[tmpK] = true; 2714 IsEndComment[tmpK] = true; 2715 } 2716 2717 if ((tmpK >= sqlTokenLen) || (nextToken > sqlTokenLen)) { 2718 IsEndComment[tmpK] = true; 2719 isEndLineComment[tmpK] = true; 2720 isEndBlockComment[tmpK] = true; 2721 } 2722 2723 if (IsInComment[tmpK]) { 2724 IsInNonFormatZone[tmpK] = true; 2725 inComment1 = true; 2726 } 2727 2728 if ((!indentBlockComment) && isInBlockComment[tmpK]) { 2729 if (IsInFrozenZone[prevToken] && (!IsEndFrozenZone[prevToken])) { 2730 IsInFrozenZone[tmpK] = true; 2731 if (isEndBlockComment[tmpK]) { 2732 IsEndFrozenZone[tmpK] = true; 2733 } 2734 } 2735 if (isStartBlockComment[tmpK]) { 2736 IsInFrozenZone[tmpK] = true; 2737 IsStartFrozenZone[tmpK] = true; 2738 } 2739 if ((tmpK >= sqlTokenLen) || (nextToken > sqlTokenLen)) { 2740 IsEndFrozenZone[tmpK] = true; 2741 } 2742 } 2743 2744 if (IsInLiteral[prevToken] && (!IsEndLiteral[prevToken])) { 2745 IsInLiteral[tmpK] = true; 2746 IsInNonFormatZone[tmpK] = true; 2747 if ((!dbname.equals(EDbVendor.dbvoracle)) && myequals(tokenArray[tmpK], literalQuote)) { 2748 if (equalsIgnoreCase(tokenArray[nextToken], literalQuote) 2749 && (tNbrOfPrecedingBlanks[nextToken] == 0)) { 2750 tokenArray[tmpK] += tokenArray[nextToken]; 2751 setToEmptyTokenInThisRange(nextToken, 1); 2752 } else { 2753 IsEndLiteral[tmpK] = true; 2754 } 2755 } 2756 if ((dbname.equals(EDbVendor.dbvoracle)) && myequals(tokenArray[tmpK], literalQuote)) { 2757 if (!myequals(s1, " ")) { 2758 if (endsWith(tokenArray[prevToken], s2) && (!IsStartLiteral[prevToken])) { 2759 IsEndLiteral[tmpK] = true; 2760 s1 = " "; 2761 s2 = " "; 2762 } 2763 } else if (equalsIgnoreCase(tokenArray[nextToken], literalQuote) 2764 && (tNbrOfPrecedingBlanks[nextToken] == 0)) { 2765 tokenArray[tmpK] += tokenArray[nextToken]; 2766 setToEmptyTokenInThisRange(nextToken, 1); 2767 } else { 2768 IsEndLiteral[tmpK] = true; 2769 } 2770 } 2771 } 2772 2773 if (!IsInNonFormatZone[tmpK]) { 2774 if ((!dbname.equals(EDbVendor.dbvoracle)) && myequals(tokenArray[tmpK], literalQuote)) { 2775 IsStartLiteral[tmpK] = true; 2776 IsInLiteral[tmpK] = true; 2777 } 2778 if ((dbname.equals(EDbVendor.dbvoracle)) && myequals(tokenArray[tmpK], literalQuote)) { 2779 IsStartLiteral[tmpK] = true; 2780 IsInLiteral[tmpK] = true; 2781 if (equalsIgnoreCase(tokenArray[prevToken], "q") && (tokenArray[nextToken].length() > 0)) { 2782 s1 = tokenArray[nextToken].substring(0, 1); 2783 if (myequals(s1, "{")) { 2784 s2 = "}"; 2785 } else if (myequals(s1, c_char_left_paren)) { 2786 s2 = c_char_right_paren; 2787 } else if (myequals(s1, "[")) { 2788 s2 = "]"; 2789 } else if (myequals(s1, "{")) { 2790 s2 = "}"; 2791 } else if (myequals(s1, c_char_less)) { 2792 s2 = c_char_great; 2793 } else { 2794 s2 = s1; 2795 } 2796 tokenArray[tmpK] += tokenArray[nextToken].substring(0, 1); 2797 if (tokenArray[nextToken].length() > 1) { 2798 tokenArray[nextToken] = tokenArray[nextToken].substring(1); 2799 } else { 2800 setToEmptyTokenInThisRange(nextToken, 1); 2801 } 2802 } 2803 } 2804 } 2805 2806 if (tmpK >= sqlTokenLen) { 2807 IsEndLiteral[tmpK] = true; 2808 } 2809 if (IsInLiteral[tmpK]) { 2810 IsInNonFormatZone[tmpK] = true; 2811 } 2812 2813 if ((dbname.equals(EDbVendor.dbvmssql) || dbname.equals(EDbVendor.dbvaccess))) { 2814 if ((!IsInLiteral[tmpK]) && (!IsInComment[tmpK])) { 2815 if (tNbrInBlock[prevToken] && (!IsEndBlock[prevToken])) { 2816 tNbrInBlock[tmpK] = true; 2817 IsInNonFormatZone[tmpK] = true; 2818 if (myequals(tokenArray[tmpK], "[")) { 2819 i1++; 2820 } 2821 if (myequals(tokenArray[tmpK], "]")) { 2822 i1--; 2823 if (i1 == 0) { 2824 IsEndBlock[tmpK] = true; 2825 } 2826 } 2827 } 2828 if ((!IsInNonFormatZone[tmpK]) && myequals(tokenArray[tmpK], "[")) { 2829 i1++; 2830 if (i1 == 1) { 2831 tNbrStartBlock[tmpK] = true; 2832 } 2833 tNbrInBlock[tmpK] = true; 2834 } 2835 if (tmpK >= sqlTokenLen) { 2836 IsEndBlock[tmpK] = true; 2837 } 2838 } 2839 if (tNbrInBlock[tmpK]) { 2840 IsInNonFormatZone[tmpK] = true; 2841 } 2842 } 2843 if (tNbrInDoubleQuotes[prevToken] && (!IsEndDoubleQuotes[prevToken])) { 2844 tNbrInDoubleQuotes[tmpK] = true; 2845 IsInNonFormatZone[tmpK] = true; 2846 if (myequals(tokenArray[tmpK], "\"") || myequals(tokenArray[tmpK], "`")) { 2847 IsEndDoubleQuotes[tmpK] = true; 2848 } 2849 if (myequals(tokenArray[tmpK], "\\\"") && escapeCharacter) { 2850 IsEndDoubleQuotes[tmpK] = true; 2851 tokenArray[tmpK] = "\""; 2852 } 2853 } 2854 if (!IsInNonFormatZone[tmpK]) { 2855 if (myequals(tokenArray[tmpK], "\"") || myequals(tokenArray[tmpK], "`")) { 2856 IsStartDoubleQuotes[tmpK] = true; 2857 tNbrInDoubleQuotes[tmpK] = true; 2858 } 2859 if (myequals(tokenArray[tmpK], "\\\"") && escapeCharacter) { 2860 IsStartDoubleQuotes[tmpK] = true; 2861 tNbrInDoubleQuotes[tmpK] = true; 2862 tokenArray[tmpK] = "\""; 2863 } 2864 } 2865 if (tmpK >= sqlTokenLen) { 2866 IsEndDoubleQuotes[tmpK] = true; 2867 } 2868 if (tNbrInDoubleQuotes[tmpK]) { 2869 IsInNonFormatZone[tmpK] = true; 2870 } 2871 2872 tmpK++; 2873 } 2874 } 2875 2876 public boolean matchByPatternYieldString(String pattern, boolean caseInsensitive, int startPos, int len, String numberOfSpace) { 2877 patternMatchedString = ""; 2878 boolean result = false; 2879 Pattern r = null; 2880 Matcher matcher = null; 2881 2882 try { 2883 r = Pattern.compile(pattern, caseInsensitive ? Pattern.CASE_INSENSITIVE : 0); 2884 matcher = r.matcher(tokenArray[startPos] + concatTokens(startPos, len, numberOfSpace)); 2885 2886 result = matcher.find(); 2887 if (result) { 2888 patternMatchedString = matcher.group(0); 2889 } 2890 } finally { 2891 if (matcher != null) { 2892 matcher.reset(); 2893 } 2894 } 2895 2896 return result; 2897 } 2898 2899 public boolean matchByPatternYieldStringAndTokenNum(String pattern, boolean caseInsensitive, int startPos, int len, String numberOfSpace) { 2900 boolean result = false; 2901 patternMatchedString = ""; 2902 patternMatchedTokenNum = 0; 2903 Pattern r = null; 2904 Matcher matcher = null; 2905 2906 try { 2907 r = Pattern.compile(pattern, caseInsensitive ? Pattern.CASE_INSENSITIVE : 0); 2908 matcher = r.matcher(tokenArray[startPos] + concatTokens(startPos, len, numberOfSpace)); 2909 2910 result = matcher.find(); 2911 if (result) { 2912 patternMatchedString = matcher.group(0); 2913 String[] tokens = patternMatchedString.split(" "); 2914 patternMatchedTokenNum = (short)tokens.length; 2915 } 2916 } finally { 2917 if (matcher != null) { 2918 matcher.reset(); 2919 } 2920 } 2921 2922 return result; 2923 } 2924 2925 public int next2SolidToken(int startPos) { 2926 nextSolidToken(startPos); 2927 nextSolidToken(posOfSearchedToken); 2928 return posOfSearchedToken; 2929 } 2930 2931 public String nextSolidToken(int i1) { 2932 String s1 = ""; 2933 boolean flag = false; 2934 posOfSearchedToken = i1; 2935 while (true) { 2936 if ((posOfSearchedToken > sqlTokenLen) || flag) { 2937 break; 2938 } 2939 posOfSearchedToken++; 2940 if (!(tokenArray[posOfSearchedToken].length() == 0)) { 2941 s1 = tokenArray[posOfSearchedToken]; 2942 flag = true; 2943 } 2944 } 2945 return s1; 2946 } 2947 2948 public String nextToken_nocomment_noempty_noleftbracket(int i1) { 2949 String s1 = ""; 2950 boolean flag = false; 2951 posOfSearchedToken = i1; 2952 while (true) { 2953 if ((posOfSearchedToken > sqlTokenLen) || flag) { 2954 break; 2955 } 2956 posOfSearchedToken++; 2957 if (!IsInComment[posOfSearchedToken] && !(tokenArray[posOfSearchedToken].length() == 0) 2958 && !myequals(tokenArray[posOfSearchedToken], c_char_left_paren)) { 2959 s1 = tokenArray[posOfSearchedToken]; 2960 flag = true; 2961 } 2962 } 2963 return s1; 2964 } 2965 2966 public int posOfNextToken_nocomment_noempty_noleftbracket(int i1) { 2967 nextToken_nocomment_noempty_noleftbracket(i1); 2968 return posOfSearchedToken; 2969 } 2970 2971 public int posOfNextToken_nonComment_nonEmpty(int i1) { 2972 strOfNextToken_nonComment_nonEmtpy(i1); 2973 return posOfSearchedToken; 2974 } 2975 2976 public int posOfPrevToken_nonEmpty(int i1) { 2977 posOfSearchedToken = i1 - 1; 2978 if ((posOfSearchedToken > 0) && (tokenArray[posOfSearchedToken].length() == 0)) { 2979 prevToken_nonEmpty(posOfSearchedToken); 2980 } 2981 return posOfSearchedToken; 2982 } 2983 2984 public String prevToken_nonComment_noEmpty(int i1) { 2985 String s1 = ""; 2986 boolean flag = false; 2987 posOfSearchedToken = i1; 2988 while (true) { 2989 if ((posOfSearchedToken <= 1) || flag) { 2990 break; 2991 } 2992 posOfSearchedToken--; 2993 if (!IsInComment[posOfSearchedToken] && !(tokenArray[posOfSearchedToken].length() == 0)) { 2994 s1 = tokenArray[posOfSearchedToken]; 2995 flag = true; 2996 } 2997 } 2998 return s1; 2999 } 3000 3001 public int prevToken_nonComment_noEmpty_returnPos(int i1) { 3002 prevToken_nonComment_noEmpty(i1); 3003 return posOfSearchedToken; 3004 } 3005 3006 public String prevToken_nonComment_nonEmpty_nonLeftBracket(int i1) { 3007 String s1 = ""; 3008 boolean flag = false; 3009 posOfSearchedToken = i1; 3010 while (true) { 3011 if ((posOfSearchedToken <= 1) || flag) { 3012 break; 3013 } 3014 posOfSearchedToken--; 3015 if (!IsInComment[posOfSearchedToken] && !(tokenArray[posOfSearchedToken].length() == 0) 3016 && !myequals(tokenArray[posOfSearchedToken], c_char_left_paren)) { 3017 s1 = tokenArray[posOfSearchedToken]; 3018 flag = true; 3019 } 3020 } 3021 return s1; 3022 } 3023 3024 public String prevToken_nonEmpty(int i1) { 3025 String s1 = ""; 3026 boolean flag = false; 3027 posOfSearchedToken = i1; 3028 while (true) { 3029 if ((posOfSearchedToken <= 1) || flag) { 3030 break; 3031 } 3032 posOfSearchedToken--; 3033 if (tokenArray[posOfSearchedToken].length() != 0) { 3034 s1 = tokenArray[posOfSearchedToken]; 3035 flag = true; 3036 } 3037 } 3038 return s1; 3039 } 3040 3041 public void mergeSquareBracketIntoOneToken() { 3042 int i1; 3043 if (tNbrInBlock[tmpK]) { 3044 if (tNbrStartBlock[tmpK]) { 3045 precedingBlanksOfBlockComment = tNbrOfPrecedingBlanks[tmpK]; 3046 } else { 3047 for (i1 = 1; i1 <= tNbrOfPrecedingBlanks[tmpK]; i1++) { 3048 blockCommentStr1 = blockCommentStr1 + " "; 3049 } 3050 } 3051 blockCommentStr1 = blockCommentStr1 + tokenArray[tmpK]; 3052 if (IsEndBlock[tmpK]) { 3053 tNbrOfPrecedingBlanks[tmpK] = precedingBlanksOfBlockComment; 3054 tokenArray[tmpK] = blockCommentStr1; 3055 tNbrStartBlock[tmpK] = true; 3056 blockCommentStr1 = ""; 3057 } else { 3058 setToEmptyTokenInThisRange(tmpK, 1); 3059 tNbrStartBlock[tmpK] = false; 3060 tNbrInBlock[tmpK] = false; 3061 IsEndBlock[tmpK] = false; 3062 } 3063 if ((linebreakBefore > 0) && !IsEndBlock[tmpK]) { 3064 linebreakAfter = linebreakBefore; 3065 linebreakBefore = 0; 3066 } 3067 } 3068 } 3069 3070 public void setCaseSegment() { 3071 int nestedCase, prevToken; 3072 nestedCase = 0; 3073 tmpK = 1; 3074 while (tmpK <= sqlTokenLen) { 3075 if (tokenArray[tmpK].length() == 0) { 3076 tmpK = skipToNonEmptyToken(tmpK + 1); 3077 } 3078 prevToken = posOfPrevToken_nonEmpty(tmpK); 3079 skipToNextNonEmptyToken(tmpK); // this will change posOfSearchedToken 3080 if (IsInCase[prevToken] && !IsEndCase[prevToken]) { 3081 IsInCase[tmpK] = true; 3082 if (!IsInNonFormatZone[tmpK]) { 3083 if (equalsIgnoreCase(tokenArray[tmpK], c_case)) { 3084 nestedCase++; 3085 } 3086 if (equalsIgnoreCase(tokenArray[tmpK], c_end)) { 3087 nestedCase--; 3088 if (nestedCase == 0) { 3089 IsEndCase[tmpK] = true; 3090 } 3091 } 3092 } 3093 } else if (!IsInNonFormatZone[tmpK] && equalsIgnoreCase(tokenArray[tmpK], c_case) 3094 && !myequals(nextSolidToken(tmpK), c_char_semicolon)) { 3095 nestedCase++; 3096 IsStartCase[tmpK] = true; 3097 IsInCase[tmpK] = true; 3098 } 3099 if (tmpK >= sqlTokenLen) { 3100 IsEndCase[tmpK] = true; 3101 } 3102 tmpK++; 3103 } 3104 } 3105 3106 public void processCaseRelated2() { 3107 int nestedCase, prevToken; 3108 nestedCase = 0; 3109 tmpK = 1; 3110 while (tmpK <= sqlTokenLen) { 3111 if (tokenArray[tmpK].length() == 0) { 3112 tmpK = skipToNonEmptyToken(tmpK + 1); 3113 } 3114 prevToken = posOfPrevToken_nonEmpty(tmpK); 3115 skipToNextNonEmptyToken(tmpK); 3116 3117 if (IsInCase[prevToken] && !IsEndCase[prevToken]) { 3118 IsInCase[tmpK] = true; 3119 if (!IsInNonFormatZone[tmpK]) { 3120 if ((equalsIgnoreCase(tokenArray[tmpK], c_case) || equalsIgnoreCase(tokenArray[tmpK], c_begin)) 3121 && !myequals(nextSolidToken(tmpK), c_char_semicolon)) { 3122 nestedCase++; 3123 } 3124 if (equalsIgnoreCase(tokenArray[tmpK], c_end)) { 3125 nestedCase--; 3126 if (nestedCase == 0) { 3127 IsEndCase[tmpK] = true; 3128 } 3129 } 3130 } 3131 } else if (!IsInNonFormatZone[tmpK] && equalsIgnoreCase(tokenArray[tmpK], c_case) 3132 && !myequals(nextSolidToken(tmpK), c_char_semicolon)) { 3133 nestedCase++; 3134 IsStartCase[tmpK] = true; 3135 IsInCase[tmpK] = true; 3136 } 3137 if (tmpK >= sqlTokenLen) { 3138 IsEndCase[tmpK] = true; 3139 } 3140 tmpK++; 3141 } 3142 } 3143 3144 public void mergeSignOfComment() { 3145 int nextpos; 3146 tmpK = 1; 3147 while (tmpK < sqlTokenLen) { 3148 if (tokenArray[tmpK].length() == 0) { 3149 tmpK = skipToNonEmptyToken(tmpK + 1); 3150 } 3151 nextpos = skipToNextNonEmptyToken(tmpK); 3152 if ((tNbrOfPrecedingBlanks[nextpos] == 0) && (tNbrOfPrecedingLinebreak[nextpos] == 0) 3153 && (endsWith(tokenArray[tmpK], "-") && (equalsIgnoreCase(tokenArray[nextpos], "-")) 3154 || equalsIgnoreCase(tokenArray[tmpK], c_char_divide) 3155 && equalsIgnoreCase(tokenArray[nextpos], c_char_divide) 3156 || equalsIgnoreCase(tokenArray[tmpK], c_char_divide) 3157 && equalsIgnoreCase(tokenArray[nextpos], c_char_star) 3158 || equalsIgnoreCase(tokenArray[tmpK], c_char_star) 3159 && equalsIgnoreCase(tokenArray[nextpos], c_char_divide))) { 3160 tokenArray[tmpK] = tokenArray[tmpK] + tokenArray[nextpos]; 3161 setToEmptyTokenInThisRange(nextpos, 1); 3162 tmpK--; 3163 } 3164 tmpK++; 3165 } 3166 } 3167 3168 public void mergeDoubleQuoteIntoOneToken() { 3169 int i1; 3170 if (tNbrInDoubleQuotes[tmpK]) { 3171 if (IsStartDoubleQuotes[tmpK]) { 3172 precedingBlanksOfDoubleQuotes = tNbrOfPrecedingBlanks[tmpK]; 3173 } else { 3174 for (i1 = 1; i1 <= tNbrOfPrecedingBlanks[tmpK]; i1++) { 3175 doubleQuotesStr1 = doubleQuotesStr1 + " "; 3176 } 3177 } 3178 doubleQuotesStr1 = doubleQuotesStr1 + tokenArray[tmpK]; 3179 if (IsEndDoubleQuotes[tmpK]) { 3180 tNbrOfPrecedingBlanks[tmpK] = precedingBlanksOfDoubleQuotes; 3181 tokenArray[tmpK] = doubleQuotesStr1; 3182 IsStartDoubleQuotes[tmpK] = true; 3183 doubleQuotesStr1 = ""; 3184 } else { 3185 setToEmptyTokenInThisRange(tmpK, 1); 3186 IsStartDoubleQuotes[tmpK] = false; 3187 tNbrInDoubleQuotes[tmpK] = false; 3188 IsEndDoubleQuotes[tmpK] = false; 3189 } 3190 if ((linebreakBefore > 0) && !IsEndDoubleQuotes[tmpK]) { 3191 linebreakAfter = linebreakBefore; 3192 linebreakBefore = 0; 3193 } 3194 } 3195 } 3196 3197 public void mergeEscapeChar() { 3198 tmpK = 1; 3199 while (tmpK < sqlTokenLen) { 3200 if (tokenArray[tmpK].length() == 0) { 3201 tmpK = skipToNonEmptyToken(tmpK + 1); 3202 } 3203 if ((tmpK < sqlTokenLen - 1) && (myequals(tokenArray[tmpK], literalQuote)) 3204 && (myequals(tokenArray[tmpK + 1], "\\")) && (myequals(tokenArray[tmpK + 2], literalQuote))) { 3205 tokenArray[tmpK] = tokenArray[tmpK] + tokenArray[tmpK + 1] + tokenArray[tmpK + 2]; 3206 setToEmptyTokenInThisRange(tmpK + 1, 2); 3207 tmpK++; 3208 continue; 3209 } 3210 3211 if ((tmpK < sqlTokenLen) && escapeCharacter && equalsIgnoreCase(tokenArray[tmpK], "\\") 3212 && (tNbrOfPrecedingBlanks[tmpK + 1] == 0)) { 3213 tokenArray[tmpK] = tokenArray[tmpK] + tokenArray[tmpK + 1]; 3214 setToEmptyTokenInThisRange(tmpK + 1, 1); 3215 } 3216 tmpK++; 3217 } 3218 } 3219 3220 public void mergeLiteralIntoOneToken() { 3221 int i1, j1; 3222 literalStr1 = ""; 3223 precedingBlanksOfLiteral = 0; 3224 blockCommentStr1 = ""; 3225 precedingBlanksOfBlockComment = 0; 3226 doubleQuotesStr1 = ""; 3227 precedingBlanksOfDoubleQuotes = 0; 3228 tmpK = 1; 3229 while (tmpK <= sqlTokenLen) { 3230 if (tokenArray[tmpK].length() == 0) { 3231 tmpK = skipToNonEmptyToken(tmpK + 1); 3232 } 3233 if (IsInLiteral[tmpK]) { 3234 if (IsStartLiteral[tmpK]) { 3235 precedingBlanksOfLiteral = tNbrOfPrecedingBlanks[tmpK]; 3236 } else { 3237 for (i1 = 1; i1 <= tNbrOfPrecedingBlanks[tmpK]; i1++) { 3238 literalStr1 = literalStr1 + " "; 3239 } 3240 for (j1 = 1; j1 <= tNbrOfPrecedingLinebreak[tmpK]; j1++) { 3241 literalStr1 = literalStr1 + lineSeparator; 3242 } 3243 } 3244 literalStr1 = literalStr1 + tokenArray[tmpK]; 3245 if (IsEndLiteral[tmpK]) { 3246 tNbrOfPrecedingBlanks[tmpK] = precedingBlanksOfLiteral; 3247 tokenArray[tmpK] = literalStr1; 3248 IsStartLiteral[tmpK] = true; 3249 literalStr1 = ""; 3250 } else { 3251 setToEmptyTokenInThisRange(tmpK, 1); 3252 IsStartLiteral[tmpK] = false; 3253 IsInLiteral[tmpK] = false; 3254 IsEndLiteral[tmpK] = false; 3255 } 3256 if ((linebreakBefore > 0) && !IsEndLiteral[tmpK]) { 3257 linebreakAfter = linebreakBefore; 3258 linebreakBefore = 0; 3259 } 3260 } 3261 mergeSquareBracketIntoOneToken(); 3262 mergeDoubleQuoteIntoOneToken(); 3263 tmpK++; 3264 } 3265 } 3266 3267 public void mergeQualifiedIdentifier() { 3268 boolean flag; 3269 tmpK = 1; 3270 label0: while (tmpK <= sqlTokenLen) { 3271 if (tokenArray[tmpK].length() == 0) { 3272 tmpK = skipToNonEmptyToken(tmpK + 1); 3273 } 3274 flag = false; 3275 if (tNbrInBlock[tmpK] || tNbrInDoubleQuotes[tmpK]) { 3276 flag = true; 3277 } else if (endsWith(tokenArray[tmpK], ".") && (tNbrInBlock[skipToNextNonEmptyToken(tmpK)] 3278 || tNbrInDoubleQuotes[skipToNextNonEmptyToken(tmpK)])) { 3279 flag = true; 3280 } 3281 if (!flag) { 3282 tmpK++; 3283 continue; 3284 } 3285 tNbrInDoubleQuotes[tmpK] = true; 3286 IsStartDoubleQuotes[tmpK] = true; 3287 IsEndDoubleQuotes[tmpK] = true; 3288 IsInNonFormatZone[tmpK] = true; 3289 while (true) { 3290 do { 3291 if (!endsWith(tokenArray[tmpK], ".") && !startsWith(nextSolidToken(tmpK), ".") 3292 || (tNbrOfPrecedingBlanks[skipToNextNonEmptyToken(tmpK)] != 0)) { 3293 tmpK++; 3294 continue label0; 3295 } 3296 if (myequals(nextSolidToken(tmpK), ".")) { 3297 tokenArray[tmpK] = tokenArray[tmpK] + nextSolidToken(tmpK); 3298 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(tmpK), 1); 3299 } 3300 } while (tNbrOfPrecedingBlanks[skipToNextNonEmptyToken(tmpK)] != 0); 3301 tokenArray[tmpK] = tokenArray[tmpK] + nextSolidToken(tmpK); 3302 setToEmptyTokenInThisRange(skipToNextNonEmptyToken(tmpK), 1); 3303 } 3304 } 3305 } 3306 3307 public void removeUnnecessaryBracket() { 3308 findUnnecessaryBracket = false; 3309 brStartToken[0] = 0; 3310 int tmpK = 1; 3311 while (tmpK <= sqlTokenLen) { 3312 if (tokenArray[tmpK].length() == 0) { 3313 tmpK = skipToNonEmptyToken(tmpK + 1); 3314 } 3315 3316 if (myequals(tokenArray[tmpK], c_char_right_paren) && !IsInNonFormatZone[tmpK] 3317 && myequals(strOfNextToken_nonComment_nonEmtpy(tmpK), c_char_right_paren) 3318 && myequals(prevToken_nonComment_noEmpty(brStartToken[blockIDByToken[tmpK]]), c_char_left_paren)) { 3319 setToEmptyTokenInThisRange(brStartToken[blockIDByToken[posOfNextToken_nonComment_nonEmpty(tmpK)]], 1); 3320 setToEmptyTokenInThisRange(posOfNextToken_nonComment_nonEmpty(tmpK), 1); 3321 count1++; 3322 findUnnecessaryBracket = true; 3323 } 3324 tmpK++; 3325 } 3326 } 3327 3328 public void resetSomeBracketArrayIfNotInASQL() { 3329 int tmpK = 1; 3330 while (tmpK <= sqlTokenLen) { 3331 if (!IsInaSQL[tmpK]) { 3332 brSQLMasterKeyword[blockIDByToken[tmpK]] = ""; 3333 brAfterSQLMasterKeyword[blockIDByToken[tmpK]] = false; 3334 brAfterInsertValuesKeyword[blockIDByToken[tmpK]] = false; 3335 } 3336 tmpK++; 3337 } 3338 } 3339 3340 public void selectStatementClauseScope() { 3341 boolean[] aflag = new boolean[numberOfLeftBracket]; 3342 boolean[] aflag1 = new boolean[numberOfLeftBracket]; 3343 boolean[] aflag2 = new boolean[numberOfLeftBracket]; 3344 boolean[] aflag3 = new boolean[numberOfLeftBracket]; 3345 boolean[] aflag4 = new boolean[numberOfLeftBracket]; 3346 boolean flag = false; 3347 int i1, j1, k2, k1, l2, l1, i3, i2, j3, j2, k3; 3348 String s1, s2, s3, s4, s5; 3349 3350 for (i1 = 0; i1 < numberOfLeftBracket; i1++) { 3351 aflag[i1] = false; 3352 aflag1[i1] = false; 3353 aflag2[i1] = false; 3354 aflag3[i1] = false; 3355 aflag4[i1] = false; 3356 } 3357 3358 int tmpK = 1; 3359 while (tmpK <= sqlTokenLen) { 3360 if (tokenArray[tmpK].length() == 0) { 3361 tmpK = skipToNonEmptyToken(tmpK + 1); 3362 } 3363 s1 = strOfNextToken_nonComment_nonEmtpy(tmpK); 3364 j1 = posOfNextToken_nonComment_nonEmpty(tmpK); 3365 k2 = blockIDByToken[tmpK]; 3366 if (flag) { 3367 IsInSELECTList[tmpK] = true; 3368 } 3369 if (aflag[k2]) { 3370 tNbrcF[tmpK] = true; 3371 } else { 3372 tNbrcF[tmpK] = false; 3373 } 3374 if (!IsInaSQL[tmpK] || IsInComment[tmpK]) { 3375 tmpK++; 3376 continue; 3377 } 3378 if (!tNbrcF[tmpK] && startTokenOfMasterSQL[tmpK] && startsWith(tokenArray[tmpK].toUpperCase(), c_select)) { 3379 IsStartSELECTList[tmpK] = true; 3380 tNbrcF[tmpK] = true; 3381 aflag[k2] = true; 3382 flag = true; 3383 } 3384 if (IsEndOfaSQL[tmpK] && aflag[k2]) { 3385 IsEndSELECTList[tmpK] = true; 3386 aflag[k2] = false; 3387 flag = false; 3388 } 3389 if (aflag[blockIDByToken[j1]] 3390 && (includeStr(c_predefined_sep + s1 + c_predefined_sep, fromWhereMoreKeywordsStr) 3391 || includeStr(c_predefined_sep + s1 + c_predefined_sep, joinStr) 3392 || equalsIgnoreCase(s1, c_char_right_paren))) { 3393 IsEndSELECTList[tmpK] = true; 3394 aflag[blockIDByToken[j1]] = false; 3395 flag = false; 3396 } 3397 tmpK++; 3398 } 3399 3400 tmpK = 1; 3401 while (tmpK <= sqlTokenLen) { 3402 if (tokenArray[tmpK].length() == 0) { 3403 tmpK = skipToNonEmptyToken(tmpK + 1); 3404 } 3405 s2 = strOfNextToken_nonComment_nonEmtpy(tmpK); 3406 k1 = posOfNextToken_nonComment_nonEmpty(tmpK); 3407 l2 = blockIDByToken[tmpK]; 3408 if (aflag1[l2]) { 3409 IsInFROM[tmpK] = true; 3410 } else { 3411 IsInFROM[tmpK] = false; 3412 } 3413 if (!IsInaSQL[tmpK] || IsInComment[tmpK]) { 3414 tmpK++; 3415 continue; 3416 } 3417 if (!IsInFROM[tmpK] 3418 && (equalsIgnoreCase(tokenArray[tmpK], c_from) 3419 || includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, joinStr)) 3420 && brSurroundsSQL[l2]) { 3421 IsStartFROM[tmpK] = true; 3422 IsInFROM[tmpK] = true; 3423 aflag1[l2] = true; 3424 } 3425 if (IsEndOfaSQL[tmpK] && aflag1[l2]) { 3426 IsEndFROM[tmpK] = true; 3427 aflag1[l2] = false; 3428 } 3429 if (aflag1[blockIDByToken[k1]] 3430 && (includeStr(c_predefined_sep + s2 + c_predefined_sep, fromWhereMoreKeywordsStr) 3431 || includeStr(c_predefined_sep + s2 + c_predefined_sep, joinStr) 3432 || equalsIgnoreCase(s2, c_char_right_paren) || equalsIgnoreCase(s2, c_with))) { 3433 IsEndFROM[tmpK] = true; 3434 aflag1[blockIDByToken[k1]] = false; 3435 } 3436 tmpK++; 3437 } 3438 3439 tmpK = 1; 3440 while (tmpK <= sqlTokenLen) { 3441 if (tokenArray[tmpK].length() == 0) { 3442 tmpK = skipToNonEmptyToken(tmpK + 1); 3443 } 3444 s3 = strOfNextToken_nonComment_nonEmtpy(tmpK); 3445 l1 = posOfNextToken_nonComment_nonEmpty(tmpK); 3446 i3 = blockIDByToken[tmpK]; 3447 if (aflag2[i3]) { 3448 IsInWHERE[tmpK] = true; 3449 } else { 3450 IsInWHERE[tmpK] = false; 3451 } 3452 if (!IsInaSQL[tmpK] || IsInComment[tmpK]) { 3453 tmpK++; 3454 continue; 3455 } 3456 if (!IsInWHERE[tmpK] && equalsIgnoreCase(tokenArray[tmpK], c_where) && brSurroundsSQL[i3]) { 3457 IsStartWHERE[tmpK] = true; 3458 IsInWHERE[tmpK] = true; 3459 aflag2[i3] = true; 3460 } 3461 if (IsInWHERE[prevToken_nonComment_noEmpty_returnPos(tmpK)] && myequals(tokenArray[tmpK], c_char_left_paren) 3462 && !brSurroundsSQL[i3]) { 3463 IsInWHERE[tmpK] = true; 3464 aflag2[i3] = true; 3465 } 3466 if (IsEndOfaSQL[tmpK] && aflag2[i3]) { 3467 IsEndWHERE[tmpK] = true; 3468 aflag2[i3] = false; 3469 } 3470 if (aflag2[blockIDByToken[l1]] 3471 && (includeStr(c_predefined_sep + s3 + c_predefined_sep, fromWhereMoreKeywordsStr) 3472 || includeStr(c_predefined_sep + s3 + c_predefined_sep, joinStr) 3473 || equalsIgnoreCase(s3, c_char_right_paren) || equalsIgnoreCase(s3, c_with))) { 3474 IsEndWHERE[tmpK] = true; 3475 aflag2[blockIDByToken[l1]] = false; 3476 } 3477 tmpK++; 3478 } 3479 3480 tmpK = 1; 3481 while (tmpK <= sqlTokenLen) { 3482 if (tokenArray[tmpK].length() == 0) { 3483 tmpK = skipToNonEmptyToken(tmpK + 1); 3484 } 3485 s4 = strOfNextToken_nonComment_nonEmtpy(tmpK); 3486 i2 = posOfNextToken_nonComment_nonEmpty(tmpK); 3487 j3 = blockIDByToken[tmpK]; 3488 if (aflag3[j3]) { 3489 IsInGROUPBY[tmpK] = true; 3490 } else { 3491 IsInGROUPBY[tmpK] = false; 3492 } 3493 if (!IsInaSQL[tmpK] || IsInComment[tmpK]) { 3494 tmpK++; 3495 continue; 3496 } 3497 if (!IsInGROUPBY[tmpK] && equalsIgnoreCase(tokenArray[tmpK], c_group_by) && brSurroundsSQL[j3]) { 3498 IsStartGROUPBY[tmpK] = true; 3499 IsInGROUPBY[tmpK] = true; 3500 aflag3[j3] = true; 3501 } 3502 if (IsInGROUPBY[prevToken_nonComment_noEmpty_returnPos(tmpK)] 3503 && myequals(tokenArray[tmpK], c_char_left_paren) && !brSurroundsSQL[j3]) { 3504 IsInGROUPBY[tmpK] = true; 3505 aflag3[j3] = true; 3506 } 3507 if (IsEndOfaSQL[tmpK] && aflag3[j3]) { 3508 IsEndGROUPBY[tmpK] = true; 3509 aflag3[j3] = false; 3510 } 3511 if (aflag3[blockIDByToken[i2]] 3512 && (includeStr(c_predefined_sep + s4 + c_predefined_sep, fromWhereMoreKeywordsStr) 3513 || includeStr(c_predefined_sep + s4 + c_predefined_sep, joinStr) 3514 || equalsIgnoreCase(s4, c_char_right_paren) && !aflag2[blockIDByToken[i2] - 1])) { 3515 IsEndGROUPBY[tmpK] = true; 3516 aflag3[blockIDByToken[i2]] = false; 3517 } 3518 tmpK++; 3519 } 3520 3521 tmpK = 1; 3522 while (tmpK <= sqlTokenLen) { 3523 if (tokenArray[tmpK].length() == 0) { 3524 tmpK = skipToNonEmptyToken(tmpK + 1); 3525 } 3526 s5 = strOfNextToken_nonComment_nonEmtpy(tmpK); 3527 j2 = posOfNextToken_nonComment_nonEmpty(tmpK); 3528 k3 = blockIDByToken[tmpK]; 3529 if (aflag4[k3]) { 3530 IsInORDERBY[tmpK] = true; 3531 } else { 3532 IsInORDERBY[tmpK] = false; 3533 } 3534 if (!IsInaSQL[tmpK] || IsInComment[tmpK]) { 3535 tmpK++; 3536 continue; 3537 } 3538 if (!IsInORDERBY[tmpK] && equalsIgnoreCase(tokenArray[tmpK], c_order_by) && brSurroundsSQL[k3]) { 3539 IsStartORDERBY[tmpK] = true; 3540 IsInORDERBY[tmpK] = true; 3541 aflag4[k3] = true; 3542 } 3543 if (IsInORDERBY[prevToken_nonComment_noEmpty_returnPos(tmpK)] 3544 && myequals(tokenArray[tmpK], c_char_left_paren) && !brSurroundsSQL[k3]) { 3545 IsInORDERBY[tmpK] = true; 3546 aflag4[k3] = true; 3547 } 3548 if (IsEndOfaSQL[tmpK] && aflag4[k3]) { 3549 IsEndORDERBY[tmpK] = true; 3550 aflag4[k3] = false; 3551 } 3552 if (aflag4[blockIDByToken[j2]] 3553 && (includeStr(c_predefined_sep + s5 + c_predefined_sep, fromWhereMoreKeywordsStr) 3554 || includeStr(c_predefined_sep + s5 + c_predefined_sep, joinStr) 3555 || equalsIgnoreCase(s5, c_char_right_paren) && !aflag2[blockIDByToken[j2] - 1])) { 3556 IsEndORDERBY[tmpK] = true; 3557 aflag4[blockIDByToken[j2]] = false; 3558 } 3559 tmpK++; 3560 } 3561 } 3562 3563 public void setBlockRelatedArray() { 3564 String tokenBeforeBracket, tokenAfterBracket; 3565 int tmpK = 1; 3566 while (tmpK <= sqlTokenLen) { 3567 if (tokenArray[tmpK].length() == 0) { 3568 tmpK = skipToNonEmptyToken(tmpK + 1); 3569 } 3570 if (IsInNonFormatZone[tmpK]) { 3571 tmpK++; 3572 continue; 3573 } 3574 if (startTokenOfMasterSQL[tmpK]) { 3575 brSurroundsSQL[blockIDByToken[tmpK]] = true; 3576 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 3577 } 3578 if ((dbname.equals(EDbVendor.dbvoracle)) && (tokenArray[tmpK].equals(c_char_equal + c_char_great))) { // '=>' 3579 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 3580 brSetPrimaryIndentToCursorPosition[blockIDByToken[tmpK]] = true; 3581 } 3582 if (!tokenArray[tmpK].equals(c_char_left_paren)) { 3583 tmpK++; 3584 continue; 3585 } 3586 3587 tokenBeforeBracket = prevToken_nonComment_nonEmpty_nonLeftBracket(tmpK); 3588 tokenAfterBracket = nextToken_nocomment_noempty_noleftbracket(tmpK); 3589 if (equalsIgnoreCase(tokenBeforeBracket, c_in)) { 3590 if (!isSelectToken(tokenAfterBracket)) { 3591 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 3592 brSetPrimaryIndentToCursorPosition[blockIDByToken[tmpK]] = true; 3593 } 3594 } else if (startTokenOfMasterSQL[posOfNextToken_nocomment_noempty_noleftbracket(tmpK)] 3595 && functionStr.contains(c_predefined_sep + tokenBeforeBracket + c_predefined_sep)) { 3596 brSetPrimaryIndentToCursorPosition[blockIDByToken[tmpK]] = true; 3597 } 3598 if ((dbname.equals(EDbVendor.dbvoracle)) && equalsIgnoreCase(tokenBeforeBracket, c_decode)) { 3599 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 3600 brSetPrimaryIndentToCursorPosition[blockIDByToken[tmpK]] = true; 3601 } 3602 tokenAfterBracket = brSQLMasterKeyword[blockIDByToken[getLastNoBracketnoCommentPos(tmpK)]]; 3603 if (equalsIgnoreCase(tokenBeforeBracket, c_values) || isInsertToken(tokenAfterBracket) 3604 || equalsIgnoreCase(tokenAfterBracket, c_insert_into) 3605 || equalsIgnoreCase(tokenAfterBracket, c_ins_into)) { 3606 brAfterInsertValuesKeyword[blockIDByToken[tmpK]] = true; 3607 } 3608 if (startsWith(tokenAfterBracket.toLowerCase(), c_create) 3609 || equalsIgnoreCase(tokenAfterBracket, c_declare_global_temporary_table) 3610 || equalsIgnoreCase(tokenAfterBracket, c_with) 3611 || (isUpdateToken(tokenAfterBracket) && equalsIgnoreCase(tokenBeforeBracket, c_set)) 3612 || equalsIgnoreCase(tokenAfterBracket, c_openquery)) { 3613 brAfterSQLMasterKeyword[blockIDByToken[tmpK]] = true; 3614 } 3615 if ((dbname.equals(EDbVendor.dbvmssql))) { 3616 if ((startsWith(tokenAfterBracket.toLowerCase(), c_declare) 3617 && endsWith(tokenAfterBracket.toLowerCase(), c_table)) 3618 || (startsWith(tokenAfterBracket.toLowerCase(), c_returns) 3619 && endsWith(tokenAfterBracket.toLowerCase(), c_table))) { 3620 brAfterSQLMasterKeyword[blockIDByToken[tmpK]] = true; 3621 } 3622 } 3623 if (!brSurroundsSQL[blockIDByToken[tmpK]] && (equalsIgnoreCase(tokenBeforeBracket, c_where) 3624 || equalsIgnoreCase(tokenBeforeBracket, c_having) || equalsIgnoreCase(tokenBeforeBracket, c_and) 3625 || equalsIgnoreCase(tokenBeforeBracket, c_not) || equalsIgnoreCase(tokenBeforeBracket, c_or) 3626 || equalsIgnoreCase(tokenBeforeBracket, c_when) || equalsIgnoreCase(tokenBeforeBracket, c_on))) { 3627 brSurroundsCondition[blockIDByToken[tmpK]] = true; 3628 } 3629 if (equalsIgnoreCase(nextToken_nocomment_noempty_noleftbracket(tmpK), c_case)) { 3630 brSurroundsCase[blockIDByToken[tmpK]] = true; 3631 } 3632 tmpK++; 3633 } 3634 } 3635 3636 public void setJoinScope() { 3637 boolean[] aflag = new boolean[numberOfLeftBracket]; 3638 boolean[] aflag1 = new boolean[numberOfLeftBracket]; 3639 String s1; 3640 3641 for (int i1 = 0; i1 < numberOfLeftBracket; i1++) { 3642 aflag[i1] = false; 3643 aflag1[i1] = false; 3644 } 3645 3646 int tmpK = 1; 3647 while (tmpK <= sqlTokenLen) { 3648 if (tokenArray[tmpK].length() == 0) { 3649 tmpK = skipToNonEmptyToken(tmpK + 1); 3650 } 3651 if (aflag[blockIDByToken[tmpK]]) { 3652 IsInJOIN[tmpK] = true; 3653 IsInJOIN_ON[tmpK] = aflag1[blockIDByToken[tmpK]]; 3654 } else { 3655 IsInJOIN[tmpK] = false; 3656 IsInJOIN_ON[tmpK] = false; 3657 } 3658 if (IsInaSQL[tmpK] && !IsInComment[tmpK] && !aflag[blockIDByToken[tmpK]] 3659 && joinStr.contains(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep)) { 3660 IsStartJOIN[tmpK] = true; 3661 IsInJOIN[tmpK] = true; 3662 aflag[blockIDByToken[tmpK]] = true; 3663 } 3664 if (IsInaSQL[tmpK] && !IsInComment[tmpK] && aflag[blockIDByToken[tmpK]] 3665 && tokenArray[tmpK].equalsIgnoreCase(c_on)) { 3666 IsStartJOIN_ON[tmpK] = true; 3667 IsInJOIN_ON[tmpK] = true; 3668 aflag1[blockIDByToken[tmpK]] = true; 3669 } 3670 if (!IsInaSQL[tmpK] || IsInComment[tmpK]) { 3671 tmpK++; 3672 continue; 3673 } 3674 if (IsEndOfaSQL[tmpK]) { 3675 if (aflag[blockIDByToken[tmpK]]) { 3676 IsEndJOIN[tmpK] = true; 3677 IsInJOIN[tmpK] = true; 3678 aflag[blockIDByToken[tmpK]] = false; 3679 } 3680 if (aflag1[blockIDByToken[tmpK]]) { 3681 IsEndJOIN_ON[tmpK] = true; 3682 IsInJOIN_ON[tmpK] = true; 3683 aflag1[blockIDByToken[tmpK]] = false; 3684 } 3685 } 3686 if (IsEndOfCompleteSQL[tmpK] && tokenArray[tmpK].equals(c_char_right_paren) 3687 && (brStartToken[blockIDByToken[tmpK]] > 0) && IsInJOIN[brStartToken[blockIDByToken[tmpK]] - 1]) { 3688 IsEndJOIN[tmpK] = true; 3689 aflag[blockIDByToken[tmpK] - 1] = false; 3690 IsEndJOIN_ON[tmpK] = true; 3691 aflag1[blockIDByToken[tmpK] - 1] = false; 3692 } 3693 if (!aflag[blockIDByToken[posOfNextToken_nonComment_nonEmpty(tmpK)]]) { 3694 tmpK++; 3695 continue; 3696 } 3697 3698 s1 = strOfNextToken_nonComment_nonEmtpy(tmpK); 3699 if ((fromWhereMoreKeywordsStr.contains(c_predefined_sep + s1 + c_predefined_sep) 3700 && !s1.equalsIgnoreCase(c_on)) || joinStr.contains(c_predefined_sep + s1 + c_predefined_sep)) { 3701 IsEndJOIN[tmpK] = true; 3702 IsInJOIN[tmpK] = true; 3703 aflag[blockIDByToken[posOfNextToken_nonComment_nonEmpty(tmpK)]] = false; 3704 IsEndJOIN_ON[tmpK] = true; 3705 IsInJOIN_ON[tmpK] = true; 3706 aflag1[blockIDByToken[posOfNextToken_nonComment_nonEmpty(tmpK)]] = false; 3707 } 3708 tmpK++; 3709 } 3710 } 3711 3712 public void setNonFormatZoneSQLServer() { 3713 boolean flag = false; 3714 boolean flag1; 3715 int i1 = 0; 3716 int k1, prevToken, nextToken; 3717 3718 int tmpK = 1; 3719 while (tmpK <= sqlTokenLen) { 3720 flag1 = false; 3721 if (tokenArray[tmpK].length() == 0) { 3722 tmpK = skipToNonEmptyToken(tmpK + 1); 3723 } 3724 if (IsStartLiteral[tmpK]) { 3725 k1 = tmpK; 3726 boolean flag2 = false; 3727 posOfSearchedToken = k1; 3728 while (true) { 3729 if ((posOfSearchedToken <= 1) || flag2) 3730 break; 3731 posOfSearchedToken--; 3732 if (tokenArray[posOfSearchedToken].equals(c_char_left_paren) 3733 && !IsInNonFormatZone[posOfSearchedToken]) { 3734 flag2 = true; 3735 } 3736 } 3737 if ((equalsIgnoreCase(prevToken_nonEmpty(posOfSearchedToken), c_openquery) 3738 && equalsIgnoreCase(nextSolidToken(tmpK), c_select))) { 3739 flag = true; 3740 } 3741 } 3742 if (flag && IsInLiteral[tmpK]) { 3743 IsInLiteral[tmpK] = false; 3744 IsStartLiteral[tmpK] = false; 3745 if (IsEndLiteral[tmpK]) { 3746 flag = false; 3747 flag1 = true; 3748 IsEndLiteral[tmpK] = false; 3749 } 3750 IsInNonFormatZone[tmpK] = false; 3751 } 3752 if ((!flag) && (!flag1)) { 3753 tmpK++; 3754 continue; 3755 } 3756 prevToken = posOfPrevToken_nonEmpty(tmpK); 3757 nextToken = skipToNextNonEmptyToken(tmpK); 3758 if (IsInNonFormatZone[prevToken] && (!IsEndBlock[prevToken]) && (!IsEndComment[prevToken]) 3759 && (!IsEndLiteral[prevToken]) && (!IsEndDoubleQuotes[prevToken])) { 3760 IsInNonFormatZone[tmpK] = true; 3761 } 3762 if (IsInComment[prevToken] && (!IsEndComment[prevToken])) { 3763 IsInComment[tmpK] = true; 3764 IsInNonFormatZone[tmpK] = true; 3765 if (isInlineComment[prevToken]) { 3766 isInlineComment[tmpK] = true; 3767 } 3768 if (isInBlockComment[prevToken]) { 3769 isInBlockComment[tmpK] = true; 3770 } 3771 if (isInlineComment[tmpK] && (tNbrOfPrecedingLinebreak[nextToken] > 0)) { 3772 isEndLineComment[tmpK] = true; 3773 IsEndComment[tmpK] = true; 3774 } 3775 if (isInBlockComment[tmpK] && tokenArray[tmpK].equals("*/")) { 3776 IsEndComment[tmpK] = true; 3777 isEndBlockComment[tmpK] = true; 3778 } 3779 } 3780 if (!IsInNonFormatZone[tmpK]) { 3781 if (tokenArray[tmpK].startsWith("--") || tokenArray[tmpK].equalsIgnoreCase("//") 3782 || ((dbname.equals(EDbVendor.dbvoracle)) && (tNbrOfPrecedingLinebreak[tmpK] > 0) 3783 && (equalsIgnoreCase(tokenArray[tmpK], c_rem) 3784 || equalsIgnoreCase(tokenArray[tmpK], c_remark) 3785 || equalsIgnoreCase(tokenArray[tmpK], c_prompt) 3786 || equalsIgnoreCase(tokenArray[tmpK], c_pro) 3787 || equalsIgnoreCase(tokenArray[tmpK], c_pause)))) { 3788 IsInComment[tmpK] = true; 3789 isInlineComment[tmpK] = true; 3790 IsStartComment[tmpK] = true; 3791 isStartLineComment[tmpK] = true; 3792 } 3793 if (tokenArray[tmpK].equals("/*")) { 3794 IsInComment[tmpK] = true; 3795 isInBlockComment[tmpK] = true; 3796 IsStartComment[tmpK] = true; 3797 isStartBlockComment[tmpK] = true; 3798 } 3799 if (isInlineComment[tmpK] && (tNbrOfPrecedingLinebreak[nextToken] > 0)) { 3800 isEndLineComment[tmpK] = true; 3801 IsEndComment[tmpK] = true; 3802 } 3803 } 3804 if (isStartLineComment[tmpK] && isInlineComment[tmpK] && (tNbrOfPrecedingLinebreak[nextToken] > 0)) { 3805 isEndLineComment[tmpK] = true; 3806 IsEndComment[tmpK] = true; 3807 } 3808 if ((tmpK == sqlTokenLen) || (nextToken > sqlTokenLen) || flag1) { 3809 IsEndComment[tmpK] = true; 3810 isEndLineComment[tmpK] = true; 3811 isEndBlockComment[tmpK] = true; 3812 } 3813 if (IsInComment[tmpK]) { 3814 IsInNonFormatZone[tmpK] = true; 3815 inComment1 = true; 3816 } 3817 if (IsInLiteral[prevToken] && !IsEndLiteral[prevToken]) { 3818 IsInLiteral[tmpK] = true; 3819 IsInNonFormatZone[tmpK] = true; 3820 if (tokenArray[tmpK].equals(literalQuote + literalQuote)) { 3821 IsEndLiteral[tmpK] = true; 3822 } 3823 } 3824 if (!IsInNonFormatZone[tmpK] && tokenArray[tmpK].equals(literalQuote + literalQuote)) { 3825 IsStartLiteral[tmpK] = true; 3826 IsInLiteral[tmpK] = true; 3827 } 3828 if ((tmpK >= sqlTokenLen) || flag1) { 3829 IsEndLiteral[tmpK] = true; 3830 } 3831 if (IsInLiteral[tmpK]) { 3832 IsInNonFormatZone[tmpK] = true; 3833 } 3834 if ((dbname.equals(EDbVendor.dbvmssql)) || (dbname.equals(EDbVendor.dbvaccess))) { 3835 if ((!IsInLiteral[tmpK] && !IsInComment[tmpK])) { 3836 if (tNbrInBlock[prevToken] && !IsEndBlock[prevToken]) { 3837 tNbrInBlock[tmpK] = true; 3838 IsInNonFormatZone[tmpK] = true; 3839 if (tokenArray[tmpK].equals("[")) { 3840 i1++; 3841 } 3842 if (tokenArray[tmpK].equals("]")) { 3843 i1--; 3844 if (i1 == 0) { 3845 IsEndBlock[tmpK] = true; 3846 } 3847 } 3848 } 3849 if (!IsInNonFormatZone[tmpK] && tokenArray[tmpK].equals("[")) { 3850 i1++; 3851 tNbrStartBlock[tmpK] = true; 3852 tNbrInBlock[tmpK] = true; 3853 } 3854 if ((tmpK >= sqlTokenLen) || flag1) { 3855 IsEndBlock[tmpK] = true; 3856 } 3857 } 3858 if (tNbrInBlock[tmpK]) { 3859 IsInNonFormatZone[tmpK] = true; 3860 } 3861 } 3862 if (tNbrInDoubleQuotes[prevToken] && !IsEndDoubleQuotes[prevToken]) { 3863 tNbrInDoubleQuotes[tmpK] = true; 3864 IsInNonFormatZone[tmpK] = true; 3865 if (tokenArray[tmpK].equals("\"")) { 3866 IsEndDoubleQuotes[tmpK] = true; 3867 } 3868 } 3869 if (!IsInNonFormatZone[tmpK] && tokenArray[tmpK].equals("\"")) { 3870 IsStartDoubleQuotes[tmpK] = true; 3871 tNbrInDoubleQuotes[tmpK] = true; 3872 } 3873 if ((tmpK >= sqlTokenLen) || flag1) { 3874 IsEndDoubleQuotes[tmpK] = true; 3875 } 3876 if (tNbrInDoubleQuotes[tmpK]) { 3877 IsInNonFormatZone[tmpK] = true; 3878 } 3879 tmpK++; 3880 } 3881 } 3882 3883 public void setPrecedingTokenOfLeftBracket_masterkey() { 3884 String s1 = ""; 3885 int blockID; 3886 3887 int tmpK = 1; 3888 while (tmpK <= sqlTokenLen) { 3889 if (tokenArray[tmpK].length() == 0) { 3890 tmpK = skipToNonEmptyToken(tmpK + 1); 3891 } 3892 3893 blockID = blockIDByToken[tmpK]; 3894 3895 if (IsInNonFormatZone[tmpK]) { 3896 tmpK++; 3897 continue; 3898 } 3899 if (tokenArray[tmpK].equals(c_char_left_paren)) { 3900 brPrecedingT[blockID] = s1; 3901 } 3902 if (startTokenOfMasterSQL[tmpK]) { 3903 brSQLMasterKeyword[blockID] = tokenArray[tmpK]; 3904 } 3905 if (!tokenArray[tmpK].equals(c_char_left_paren) && !tokenArray[tmpK].equals(c_char_right_paren)) { 3906 s1 = tokenArray[tmpK]; 3907 } 3908 3909 tmpK++; 3910 } 3911 } 3912 3913 public void setToEmptyTokenInThisRange(int startPos, int range) { 3914 int k1 = startPos; 3915 while ((k1 < startPos + range) && (k1 <= sqlTokenLen)) { 3916 tokenArray[k1] = ""; 3917 tNbrOfPrecedingBlanks[k1] = 0; 3918 tNbrOfPrecedingLinebreak[k1] = 0; 3919 k1++; 3920 } 3921 } 3922 3923 public int skipToNextNonEmptyToken(int i1) { 3924 int j1 = sqlTokenLen + 1; 3925 boolean flag = false; 3926 posOfSearchedToken = i1 + 1; 3927 while ((posOfSearchedToken <= sqlTokenLen) && (!flag)) { 3928 if (!(tokenArray[posOfSearchedToken].length() == 0)) { 3929 j1 = posOfSearchedToken; 3930 flag = true; 3931 } 3932 posOfSearchedToken++; 3933 } 3934 3935 return j1; 3936 } 3937 3938 public int skipToNonEmptyToken(int i1) { 3939 int j1 = sqlTokenLen + 1; 3940 boolean flag = false; 3941 posOfSearchedToken = i1; 3942 while ((posOfSearchedToken <= sqlTokenLen) && (!flag)) { 3943 if (!(tokenArray[posOfSearchedToken].length() == 0)) { 3944 j1 = posOfSearchedToken; 3945 flag = true; 3946 } 3947 posOfSearchedToken++; 3948 } 3949 3950 return j1; 3951 } 3952 3953 public void SQLLevelAndScope() { 3954 short accumulateSQLID = 0; 3955 int tmpBlockID = 0; 3956 short nestedCase = 0; 3957 short currentSQLID = 0; 3958 int l1 = 0; 3959 String nextSolidToken = ""; 3960 3961 int tmpK = 1; 3962 while (tmpK <= sqlTokenLen) { 3963 if (tokenArray[tmpK].length() == 0) { 3964 tmpK = skipToNonEmptyToken(tmpK + 1); 3965 } 3966 3967 int prevToken = posOfPrevToken_nonEmpty(tmpK); 3968 int nextToken = skipToNextNonEmptyToken(tmpK); 3969 3970 if (IsInaSQL[prevToken] && !IsEndOfCompleteSQL[prevToken]) { 3971 IsInaSQL[tmpK] = true; 3972 SQLIDByToken[tmpK] = currentSQLID; 3973 } else { 3974 IsInaSQL[tmpK] = false; 3975 } 3976 3977 if ((tokenArray[tmpK].equalsIgnoreCase(c_char_left_paren) && !IsInNonFormatZone[tmpK] 3978 || IsStartComment[tmpK] && ((tNbrOfPrecedingLinebreak[tmpK] > 0) || (tmpK == 1))) && (l1 == 0) 3979 && startTokenOfMasterSQL[posOfNextToken_nonComment_nonEmpty(tmpK)]) { 3980 accumulateSQLID++; 3981 currentSQLID = accumulateSQLID; 3982 SQLIDByToken[tmpK] = currentSQLID; 3983 bracketsInSQL[currentSQLID] = bracketsInBlock[blockIDByToken[tmpK]]; 3984 l1 = tmpK; 3985 boolean flag3 = false; 3986 short word5 = 0; 3987 posOfSearchedToken = l1; 3988 3989 while (true) { 3990 if ((posOfSearchedToken > sqlTokenLen) || flag3) { 3991 break; 3992 } 3993 posOfSearchedToken++; 3994 if (!IsInComment[posOfSearchedToken] 3995 && !tokenArray[posOfSearchedToken].equalsIgnoreCase(c_char_left_paren) 3996 && (tokenArray[posOfSearchedToken].length() != 0)) { 3997 flag3 = true; 3998 } 3999 if (!IsInComment[posOfSearchedToken] 4000 && tokenArray[posOfSearchedToken].equalsIgnoreCase(c_char_left_paren)) { 4001 word5++; // never reach here in all oracle sqls test case 4002 } 4003 } 4004 bracketsInSQL[currentSQLID] += word5; 4005 l1 = 1; 4006 if (tokenArray[tmpK].equalsIgnoreCase(c_char_left_paren)) { 4007 SQLStartWithBracket[currentSQLID] = true; 4008 } 4009 if (IsStartComment[tmpK] && ((tNbrOfPrecedingLinebreak[tmpK] > 0) || (tmpK == 1))) { 4010 SQLStartWithComment[currentSQLID] = true; 4011 } 4012 4013 IsStartOfaSQL[tmpK] = true; 4014 SQLStartsAtT[currentSQLID] = tmpK; 4015 if (!IsInaSQL[tmpK]) { 4016 tmpBlockID = blockIDByToken[tmpK]; 4017 blockIsSQL[tmpBlockID] = true; 4018 IsInaSQL[tmpK] = true; 4019 } else { 4020 SQLIsSubSQL[currentSQLID] = true; 4021 } 4022 } 4023 4024 if (!IsInNonFormatZone[tmpK] && startTokenOfMasterSQL[tmpK]) { 4025 if (l1 == 0) { 4026 accumulateSQLID++; 4027 currentSQLID = accumulateSQLID; 4028 SQLIDByToken[tmpK] = currentSQLID; 4029 bracketsInSQL[currentSQLID] = bracketsInBlock[blockIDByToken[tmpK]]; 4030 SQLbL[currentSQLID] = true; 4031 IsStartOfaSQL[tmpK] = true; 4032 SQLStartsAtT[currentSQLID] = tmpK; 4033 if (!IsInaSQL[tmpK]) { 4034 tmpBlockID = blockIDByToken[tmpK]; 4035 blockIsSQL[tmpBlockID] = true; 4036 IsInaSQL[tmpK] = true; 4037 } else { 4038 SQLIsSubSQL[currentSQLID] = true; 4039 } 4040 } 4041 l1 = 0; 4042 } 4043 4044 if (!IsInNonFormatZone[tmpK] || IsEndLiteral[tmpK] || IsEndBlock[tmpK] || IsEndDoubleQuotes[tmpK]) { 4045 nextSolidToken = strOfNextToken_nonComment_nonEmtpy(tmpK); 4046 if (IsInaSQL[tmpK]) { 4047 if (tmpK >= sqlTokenLen) { 4048 IsEndOfaSQL[tmpK] = true; 4049 SQLEndsAtT[currentSQLID] = tmpK; 4050 IsEndOfCompleteSQL[tmpK] = true; 4051 } 4052 if (tokenArray[tmpK].equalsIgnoreCase(c_char_semicolon)) { 4053 IsEndOfaSQL[tmpK] = true; 4054 SQLEndsAtT[currentSQLID] = tmpK; 4055 IsEndOfCompleteSQL[tmpK] = true; 4056 } 4057 if (tokenArray[tmpK].equalsIgnoreCase(c_char_right_paren)) { 4058 if (startTokenOfMasterSQL[posOfNextToken_nonComment_nonEmpty(tmpK)]) { 4059 IsEndOfaSQL[tmpK] = true; 4060 SQLEndsAtT[currentSQLID] = tmpK; 4061 if (bracketsInBlock[blockIDByToken[nextToken]] <= bracketsInBlock[tmpBlockID]) { 4062 IsEndOfCompleteSQL[tmpK] = true; 4063 } 4064 } 4065 if (brSurroundsSQL[blockIDByToken[tmpK]]) { 4066 IsEndOfaSQL[tmpK] = true; 4067 SQLEndsAtT[currentSQLID] = tmpK; 4068 } 4069 if (blockIDByToken[nextToken] < tmpBlockID) { 4070 IsEndOfCompleteSQL[tmpK] = true; 4071 } 4072 } 4073 if (!tokenArray[tmpK].equalsIgnoreCase(c_char_left_paren) 4074 && !tokenArray[tmpK].equalsIgnoreCase(c_when_matched) 4075 && !tokenArray[tmpK].equalsIgnoreCase(c_when_not_matched) 4076 && !tokenArray[tmpK].equalsIgnoreCase(c_char_right_paren) && (l1 == 0) 4077 && startTokenOfMasterSQL[posOfNextToken_nonComment_nonEmpty(tmpK)]) { 4078 IsEndOfaSQL[tmpK] = true; 4079 SQLEndsAtT[currentSQLID] = tmpK; 4080 if (blockIDByToken[tmpK] == tmpBlockID) { 4081 IsEndOfCompleteSQL[tmpK] = true; 4082 } 4083 } 4084 if ((dbname.equals(EDbVendor.dbvoracle)) && (blockIDByToken[nextToken] == tmpBlockID) 4085 && (nextSolidToken.equalsIgnoreCase(c_run) || nextSolidToken.equals("/")) 4086 && (tNbrOfPrecedingLinebreak[nextToken] > 0)) { 4087 IsEndOfaSQL[tmpK] = true; 4088 SQLEndsAtT[currentSQLID] = tmpK; 4089 IsEndOfCompleteSQL[tmpK] = true; 4090 } 4091 if ((dbname.equals(EDbVendor.dbvmssql))) { 4092 if (tokenArray[tmpK].equalsIgnoreCase(c_case)) { 4093 nestedCase++; 4094 } 4095 if (tokenArray[tmpK].equalsIgnoreCase(c_end) && (nestedCase > 0)) { 4096 nestedCase--; 4097 } 4098 if ((tokenArray[tmpK].equalsIgnoreCase(c_char_right_paren) 4099 && (blockIDByToken[nextToken] <= tmpBlockID)) 4100 || (!tokenArray[tmpK].equalsIgnoreCase(c_char_right_paren) 4101 && (blockIDByToken[tmpK] <= tmpBlockID)) && (nestedCase == 0)) { 4102 if (nextSolidToken.equalsIgnoreCase(c_set)) { 4103 if (!brSQLMasterKeyword[blockIDByToken[nextToken]].equalsIgnoreCase(c_update)) { 4104 IsEndOfaSQL[tmpK] = true; 4105 SQLEndsAtT[currentSQLID] = tmpK; 4106 IsEndOfCompleteSQL[tmpK] = true; 4107 } 4108 } else if (includeStr(c_predefined_sep + nextSolidToken + c_predefined_sep, 4109 sqlServerSPRelatedSqlStr)) { 4110 IsEndOfaSQL[tmpK] = true; 4111 SQLEndsAtT[currentSQLID] = tmpK; 4112 IsEndOfCompleteSQL[tmpK] = true; 4113 } 4114 } 4115 } 4116 } 4117 4118 if (IsEndOfaSQL[tmpK] && !IsEndOfCompleteSQL[tmpK]) { 4119 boolean flag1 = false; 4120 short word3 = 0; 4121 short prevSQLID = (short) (currentSQLID - 1); 4122 while ((prevSQLID > 0) && !flag1) { 4123 if ((bracketsInSQL[prevSQLID] < bracketsInSQL[currentSQLID]) 4124 && (SQLEndsAtT[prevSQLID] > tmpK)) { 4125 flag1 = true; 4126 word3 = prevSQLID; 4127 } 4128 prevSQLID--; 4129 } 4130 4131 if (flag1) { 4132 currentSQLID = word3; 4133 } 4134 } 4135 4136 if (IsEndOfCompleteSQL[tmpK]) { 4137 currentSQLID = 0; 4138 } 4139 } 4140 4141 if ((includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, fromWhereMoreKeywordsStr) 4142 || includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, joinStr)) 4143 && (tokenArray[tmpK].length() > longestMasterKeywordsInSQL[SQLIDByToken[tmpK]])) { 4144 longestMasterKeywordsInSQL[SQLIDByToken[tmpK]] = (short) tokenArray[tmpK].length(); 4145 } 4146 4147 if (!startTokenOfMasterSQL[tmpK]) { 4148 tmpK++; 4149 continue; 4150 } 4151 4152 if (!brStartWithMasterKey[blockIDByToken[tmpK]] && !linebreakAfterLeftBracketsOfSubSelect) { 4153 if ((tokenArray[tmpK].length() + 1) > longestMasterKeywordsInSQL[SQLIDByToken[tmpK]]) { 4154 longestMasterKeywordsInSQL[SQLIDByToken[tmpK]] = (short) (tokenArray[tmpK].length() + 1); 4155 } 4156 tmpK++; 4157 continue; 4158 } 4159 4160 if (tokenArray[tmpK].length() > longestMasterKeywordsInSQL[SQLIDByToken[tmpK]]) { 4161 longestMasterKeywordsInSQL[SQLIDByToken[tmpK]] = (short) tokenArray[tmpK].length(); 4162 } 4163 4164 tmpK++; 4165 } 4166 } 4167 4168 public String strOfNextToken_nonComment_nonEmtpy(int i1) { 4169 String s1 = ""; 4170 boolean flag = false; 4171 posOfSearchedToken = i1; 4172 while (true) { 4173 if ((posOfSearchedToken > sqlTokenLen) || flag) { 4174 break; 4175 } 4176 posOfSearchedToken++; 4177 if (!IsInComment[posOfSearchedToken] && tokenArray[posOfSearchedToken].length() != 0) { 4178 s1 = tokenArray[posOfSearchedToken]; 4179 flag = true; 4180 } 4181 } 4182 return s1; 4183 } 4184 4185 public void checkOutputSQLBuffer() { 4186 for (int word0 = 1; word0 <= tNbrOfPrecedingLinebreakOutputSQL[tmpK]; word0++) { 4187 alignStyle = 0; 4188 lineNumber++; 4189 if (lineNumber >= PRE_LOCATED_LINES) { 4190 PRE_LOCATED_LINES += 1000; 4191 4192 indentOfEachline = Arrays.copyOf(indentOfEachline, PRE_LOCATED_LINES); 4193 indentOfEachlineWithPaddingSpace = Arrays.copyOf(indentOfEachlineWithPaddingSpace, PRE_LOCATED_LINES); 4194 dR = Arrays.copyOf(dR, PRE_LOCATED_LINES); 4195 } 4196 if (indentLength >= 0) 4197 indentOfEachline[lineNumber] = indentLength; 4198 else 4199 indentOfEachline[lineNumber] = 0; 4200 4201 if (indentOfEachline[lineNumber] + adjustLeadingSpace >= 0) 4202 indentOfEachlineWithPaddingSpace[lineNumber] = indentOfEachline[lineNumber] + adjustLeadingSpace; 4203 else 4204 indentOfEachlineWithPaddingSpace[lineNumber] = 0; 4205 4206 ColumnPosOfCurrentToken = (short)indentOfEachlineWithPaddingSpace[lineNumber]; 4207 } 4208 } 4209 4210 public void doAddProcessedTokenToStringBuilder() { 4211 bX.append(tokenArray[tmpK]); 4212 } 4213 4214 public void doAlign() { 4215 if (alignEqualSigns && !IsInNonFormatZone[tmpK] 4216 && (!IsInaSQL[tmpK] || IsInaSQL[tmpK] && !formatSQLOn1Line && !IsInSmallSQL[tmpK]) 4217 && (tokenArray[tmpK].equalsIgnoreCase(c_char_equal) || tokenArray[tmpK].equalsIgnoreCase(c_char_great) 4218 || tokenArray[tmpK].equalsIgnoreCase(c_char_less) 4219 || tokenArray[tmpK].equalsIgnoreCase(c_char_less + c_char_equal) 4220 || tokenArray[tmpK].equalsIgnoreCase(c_char_great + c_char_equal) 4221 || tokenArray[tmpK].equalsIgnoreCase(c_char_colon + c_char_equal) 4222 || tokenArray[tmpK].equalsIgnoreCase(c_char_exclamation + c_char_equal) 4223 || tokenArray[tmpK].equalsIgnoreCase(c_char_less + c_char_great) 4224 || tokenArray[tmpK].equalsIgnoreCase(c_char_equal + c_char_star) 4225 || tokenArray[tmpK].equalsIgnoreCase(c_char_colon + c_char_equal) 4226 || tokenArray[tmpK].equalsIgnoreCase(c_char_equal + c_char_colon) 4227 || tokenArray[tmpK].equalsIgnoreCase(c_char_star + c_char_equal) 4228 || tokenArray[tmpK].equalsIgnoreCase(c_is_null) 4229 || tokenArray[tmpK].equalsIgnoreCase(c_is_not_null) || tokenArray[tmpK].equalsIgnoreCase(c_like) 4230 || tokenArray[tmpK].equalsIgnoreCase(c_not_like))) { 4231 alignToken(tmpK, 1, align_right, boolean_no); 4232 } 4233 if (alignAliasName && IsInaSQL[tmpK] && !IsInNonFormatZone[tmpK] 4234 && (linebreakAfterComma || linebreakBeforeComma) && !IsInSmallSQL[tmpK] && !formatSQLOn1Line 4235 && (tokenArray[tmpK].equalsIgnoreCase(c_as) && !prevToken_nonEmpty(tmpK).equalsIgnoreCase(c_as) 4236 || IsAlias[tmpK])) { 4237 int i1 = alignAliasNamePos - ColumnPosOfCurrentToken - tNbrOfPrecedingBlanks[tmpK]; 4238 if (alignAliasNameAtPredefinedPos && i1 > 0) 4239 tNbrOfPrecedingBlanks[tmpK] += i1; 4240 alignToken(tmpK, 2, align_left, boolean_no); 4241 } 4242 if (SPAlignDeclareVariable && !IsInNonFormatZone[tmpK] 4243 && (includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, datatypeStr) 4244 || tokenArray[tmpK].equalsIgnoreCase(c_exception) 4245 && strOfNextToken_nonComment_nonEmtpy(tmpK).equalsIgnoreCase(c_char_semicolon)) 4246 && (!IsInaSQL[tmpK] 4247 && !(dbname.equals(EDbVendor.dbvoracle) && (prevToken1.equalsIgnoreCase(c_in) 4248 || prevToken1.equalsIgnoreCase(c_out) || prevToken1.equalsIgnoreCase(c_inout))) 4249 || IsInaSQL[tmpK] && !formatSQLOn1Line && !IsInSmallSQL[tmpK])) { 4250 alignToken(tmpK, 3, align_left, boolean_no); 4251 } 4252 if (alignLineComment && !isInBlockComment[tmpK] && tNbrOfPrecedingLinebreakOutputSQL[tmpK] == 0 4253 && isStartLineComment[tmpK] && tNbrOfPrecedingLinebreak[tmpK] == 0 && isStartLineComment[tmpK]) { 4254 alignToken(tmpK, 4, align_right, boolean_yes); 4255 } 4256 if (alignOperator && !IsInNonFormatZone[tmpK] 4257 && (!IsInaSQL[tmpK] || IsInaSQL[tmpK] && !formatSQLOn1Line && !IsInSmallSQL[tmpK]) 4258 && (tokenArray[tmpK].equalsIgnoreCase(c_char_plus) || tokenArray[tmpK].equalsIgnoreCase(c_char_minus) 4259 || tokenArray[tmpK].equalsIgnoreCase(c_char_star) 4260 || tokenArray[tmpK].equalsIgnoreCase(c_char_star + c_char_star) 4261 || tokenArray[tmpK].equalsIgnoreCase(c_char_divide) 4262 || tokenArray[tmpK].equalsIgnoreCase(c_in))) { 4263 alignToken(tmpK, 5, align_right, boolean_no); 4264 } 4265 if (tokenArray[tmpK].equalsIgnoreCase("||") && !IsInNonFormatZone[tmpK] && alignConcateOP 4266 && linebreakAfterConcatenations) { 4267 alignToken(tmpK, 10, align_right, boolean_yes); 4268 } 4269 if (tokenArray[tmpK].equalsIgnoreCase(c_on) && IsInJOIN[tmpK] && !IsInNonFormatZone[tmpK] 4270 && !breakBeforeONkeyword) { 4271 alignToken(tmpK, 11, align_right, boolean_yes); 4272 } 4273 if (tokenArray[tmpK].equalsIgnoreCase(",") 4274 && !(dbname.equals(EDbVendor.dbvoracle) && prevToken_nonEmpty(tmpK).equalsIgnoreCase(c_decode))) { 4275 if ((alignStyle == 1) && !IsInNonFormatZone[tmpK] && alignCommaInList 4276 && brWithCommaLineBreak[blockIDByToken[tmpK]] && !bY) { 4277 alignToken(tmpK, 12, align_right, boolean_yes); 4278 } 4279 if ((alignStyle == 2) && !IsInNonFormatZone[tmpK] && alignCommaInList 4280 && brWithCommaLineBreak[blockIDByToken[tmpK]] && !bY && numberOfIdentifiersPerLine > 1) { 4281 alignToken(tmpK, 13, align_right, boolean_yes); 4282 } 4283 if ((alignStyle == 3) && !IsInNonFormatZone[tmpK] && alignCommaInList 4284 && brWithCommaLineBreak[blockIDByToken[tmpK]] && !bY && numberOfIdentifiersPerLine > 1) { 4285 alignToken(tmpK, 14, align_right, boolean_yes); 4286 } 4287 if ((alignStyle == 4) && !IsInNonFormatZone[tmpK] && alignCommaInList 4288 && brWithCommaLineBreak[blockIDByToken[tmpK]] && !bY && numberOfIdentifiersPerLine > 1) { 4289 alignToken(tmpK, 15, align_right, boolean_yes); 4290 } 4291 } 4292 if (alignAliasName && !IsInNonFormatZone[tmpK] && (linebreakAfterComma || linebreakBeforeComma) 4293 && !IsInSmallSQL[tmpK] && !formatSQLOn1Line && IsAlias[tmpK]) { 4294 alignToken(tmpK, 16, align_left, boolean_yes); 4295 } 4296 } 4297 4298 public void doApplyDebugInstruction() { 4299 // Implementation goes here 4300 } 4301 4302 public void doCalculateNbrOfPrecedingBlanks1() { 4303 int i1 = 0; 4304 if (IsInaSQL[tmpK] && !IsInSmallSQL[tmpK] && !IsInComment[tmpK] && !formatSQLOn1Line 4305 && (linebreakBefore == 0)) { 4306 if (isSelectToken(tokenArray[tmpK]) && equalsIgnoreCase(prevToken_nonEmpty(tmpK), c_char_left_paren) 4307 && !linebreakAfterLeftBracketsOfSubSelect) { 4308 if (rightAlignMasterKeywords) { 4309 i1 = currentIndentSize - tokenArray[tmpK].length() - 2; 4310 } else { 4311 i1 = -1 * tNbrOfPrecedingBlanks[tmpK]; 4312 } 4313 } 4314 if ((equalsIgnoreCase(prevToken2, c_and) || equalsIgnoreCase(prevToken2, c_or)) && !indentANDOR 4315 && linebreakBeforeAndOr) { 4316 if (rightAlignMasterKeywords) { 4317 i1 = 0; 4318 } else { 4319 i1 = currentIndentSize - prevToken2.length() - 1; 4320 } 4321 } 4322 if (CanSetLineBreakAfter[prevTokenPos1] && !breakAfterMasterKeyword) { 4323 if (includeStr(c_predefined_sep + prevToken2 + c_predefined_sep, fromWhereMoreKeywordsStr) 4324 && (!equalsIgnoreCase(prevToken2, c_on) || equalsIgnoreCase(prevToken2, c_on)) 4325 && IsInJOIN[prevTokenPos1] && breakBeforeONkeyword 4326 || equalsIgnoreCase(prevToken2, c_fetch) 4327 || (!indentJoinStatement 4328 && includeStr(c_predefined_sep + prevToken2 + c_predefined_sep, joinStr)) 4329 || (equalsIgnoreCase(prevToken2, c_set) 4330 && isUpdateToken(brSQLMasterKeyword[blockIDByToken[tmpK]])) 4331 || equalsIgnoreCase(prevToken2, c_into)) { 4332 if (myequals(tokenArray[tmpK], c_char_left_paren) && brSurroundsSQL[blockIDByToken[tmpK]] 4333 && flexibleSpaceCalculation) { 4334 if (rightAlignMasterKeywords) { 4335 i1 = 0; 4336 } else { 4337 i1 = (longestMasterKeywordsInSQL[SQLIDByToken[prevTokenPos1]] + 1) - prevToken2.length() 4338 - 1; 4339 } 4340 } else { 4341 if (rightAlignMasterKeywords) { 4342 i1 = 0; 4343 } else { 4344 i1 = currentIndentSize - prevToken2.length() - 1; 4345 } 4346 } 4347 } 4348 if ((equalsIgnoreCase(prevToken2, c_case) && linebreakForCase 4349 || equalsIgnoreCase(prevToken2, c_when) && linebreakForCase && linebreakBeforeCaseWhen 4350 || equalsIgnoreCase(prevToken2, c_then) && linebreakForCase && linebreakBeforeCaseThen 4351 || equalsIgnoreCase(prevToken2, c_else) && linebreakForCase && linebreakBeforeCaseElse)) { 4352 i1 = currentIndentSize - prevToken2.length() - 1; 4353 } 4354 if (isSelectToken(prevToken2)) { 4355 if (equalsIgnoreCase(prevprevToken, c_char_left_paren) && !linebreakAfterLeftBracketsOfSubSelect) { 4356 if (rightAlignMasterKeywords) { 4357 i1 = 0; 4358 } else { 4359 i1 = currentIndentSize - prevToken2.length() - 2; 4360 } 4361 } else { 4362 if (rightAlignMasterKeywords) { 4363 i1 = 0; 4364 } else { 4365 i1 = currentIndentSize - prevToken2.length() - 1; 4366 } 4367 } 4368 if (indentMasterKeyword) { 4369 if (i1 < 0) { 4370 i1 = 0 + currentIndentSize; 4371 } else { 4372 i1 = i1 + currentIndentSize; 4373 } 4374 } 4375 } 4376 } 4377 } 4378 if (i1 < 0) { 4379 i1 = 0; 4380 } 4381 tNbrOfPrecedingBlanks[tmpK] = tNbrOfPrecedingBlanks[tmpK] + i1; 4382 } 4383 4384 public void doCalculatePrecedingSpace1() { 4385 if (formatSQLOn1Line && IsInaSQL[tmpK] && equalsIgnoreCase(tokenArray[tmpK], c_from)) { 4386 tNbrOfPrecedingBlanks[skipToNextNonEmptyToken(tmpK)]++; 4387 } 4388 if ((!isInBlockComment[tmpK] || isInBlockComment[tmpK] && leftAlignBlockComment) && (linebreakBefore > 0)) { 4389 tNbrOfPrecedingBlanks[tmpK] = 0; 4390 } 4391 if (IsInaSQL[tmpK] && !IsInNonFormatZone[tmpK] && myequals(tokenArray[posOfPrevToken_nonEmpty(tmpK)], ",") 4392 && linebreakBeforeComma && brWithCommaLineBreak[blockIDByToken[tmpK]] && alwaysPut1SpaceAfterComma) { 4393 tNbrOfPrecedingBlanks[tmpK] = Math.max(1, tNbrOfPrecedingBlanks[tmpK]); 4394 } 4395 } 4396 4397 public void doColorSQL() { 4398 // Implementation goes here 4399 } 4400 4401 public void doIndentRelated() { 4402 int i1 = 0; 4403 adjustLeadingSpace = 0; 4404 if (IsInaSQL[tmpK] && !IsInNonFormatZone[tmpK] && (linebreakBefore > 0)) { 4405 i1 = tokenArray[tmpK].length(); 4406 if (tokenArray[tmpK].length() >= currentIndentSize) { 4407 i1 = currentIndentSize - 1; 4408 } 4409 if (myequals(tokenArray[tmpK], ",") && linebreakBeforeComma && brWithCommaLineBreak[blockIDByToken[tmpK]] 4410 && moveComma2colsToTheLeft) { 4411 adjustLeadingSpace = (adjustLeadingSpace - i1 - 1); 4412 } 4413 if (rightAlignMasterKeywords && tNbrKeyword1[tmpK]) { 4414 if ((equalsIgnoreCase(tokenArray[tmpK], c_and) || equalsIgnoreCase(tokenArray[tmpK], c_or)) 4415 && !indentANDOR && linebreakBeforeAndOr) { 4416 adjustLeadingSpace = ((adjustLeadingSpace + currentIndentSize) - tokenArray[tmpK].length() - 1); 4417 } 4418 if (startTokenOfMasterSQL[tmpK] 4419 && (!myequals(prevToken2, c_char_left_paren) || linebreakAfterLeftBracketsOfSubSelect) 4420 || includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, joinStr) 4421 || includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, fromWhereMoreKeywordsStr) 4422 || equalsIgnoreCase(tokenArray[tmpK], c_set) 4423 && isUpdateToken(brSQLMasterKeyword[blockIDByToken[tmpK]])) { 4424 adjustLeadingSpace = ((adjustLeadingSpace + currentIndentSize) - tokenArray[tmpK].length() - 1); 4425 } else if (equalsIgnoreCase(tokenArray[tmpK], c_char_left_paren) && brSurroundsSQL[blockIDByToken[tmpK]] 4426 || equalsIgnoreCase(tokenArray[tmpK], c_char_right_paren) 4427 && brSurroundsSQL[blockIDByToken[tmpK]]) { 4428 adjustLeadingSpace = (adjustLeadingSpace + 1); 4429 } 4430 } 4431 if (linebreakAfterConcatenations && (myequals(prevToken_nonEmpty(tmpK), "||") 4432 || equalsIgnoreCase(prevToken_nonEmpty(tmpK), c_concat))) { 4433 adjustLeadingSpace = (adjustLeadingSpace + currentIndentSize); 4434 } else if (linebreakBeforeConcatenations 4435 && (myequals(tokenArray[tmpK], "||") || equalsIgnoreCase(tokenArray[tmpK], c_concat))) { 4436 adjustLeadingSpace = (adjustLeadingSpace + currentIndentSize); 4437 } 4438 } 4439 if (!IsInaSQL[tmpK] && !IsInNonFormatZone[tmpK] && (linebreakBefore > 0) && myequals(tokenArray[tmpK], ",") 4440 && linebreakBeforeComma && brSurroundsParams[blockIDByToken[tmpK]]) { 4441 adjustLeadingSpace = (adjustLeadingSpace - tokenArray[tmpK].length() - 1); 4442 } 4443 } 4444 4445 public void doModifyCase() { 4446 if (!(tNbrInDoubleQuotes[tmpK] && IsEndDoubleQuotes[tmpK])) { 4447 if (!(equalsIgnoreCase(outputFormat, c_vb_string))) { 4448 tokenArray[tmpK] = tokenArray[tmpK].replaceAll("\"", "\"\""); 4449 } else if (!(equalsIgnoreCase(outputFormat, c_sql))) { 4450 tokenArray[tmpK] = tokenArray[tmpK].replaceAll("\"", "\\\""); 4451 } 4452 } 4453 if (replaceHostVariable && !IsInComment[tmpK] && tokenArray[tmpK].startsWith(c_char_colon)) { 4454 hostVariableRelatedCount++; 4455 if (putHostVariableBetweenSlashStar) { 4456 tokenArray[tmpK] = (c_char_question_mark + " /* " + tokenArray[tmpK] + " */"); 4457 } else { 4458 tokenArray[tmpK] = c_char_question_mark; 4459 } 4460 } 4461 if (!IsInNonFormatZone[tmpK]) { 4462 if (keywordUpper && (tNbrKeyword1[tmpK] || isFunction(tokenArray[tmpK], functionList) 4463 || includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, caseCustomizedKeywords) 4464 || includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, 4465 caseCustomizedVariableType))) { 4466 tokenArray[tmpK] = tokenArray[tmpK].toUpperCase(); 4467 } 4468 if (keywordLower && (tNbrKeyword1[tmpK] || isFunction(tokenArray[tmpK], functionList) 4469 || includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, caseCustomizedKeywords) 4470 || includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, 4471 caseCustomizedVariableType))) { 4472 tokenArray[tmpK] = tokenArray[tmpK].toLowerCase(); 4473 } 4474 if (onlyKeywordUpper) { 4475 if (tNbrKeyword1[tmpK] || isFunction(tokenArray[tmpK], functionList) 4476 || includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, caseCustomizedKeywords) 4477 || includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, 4478 caseCustomizedVariableType)) { 4479 tokenArray[tmpK] = tokenArray[tmpK].toUpperCase(); 4480 } else { 4481 tokenArray[tmpK] = tokenArray[tmpK].toLowerCase(); 4482 } 4483 } 4484 if (wholeUpper) { 4485 tokenArray[tmpK] = tokenArray[tmpK].toUpperCase(); 4486 } 4487 if (wholeLower) { 4488 tokenArray[tmpK] = tokenArray[tmpK].toLowerCase(); 4489 } 4490 } 4491 } 4492 4493 public void prepareForNextToken() { 4494 ColumnPosOfCurrentToken += tNbrOfPrecedingBlanks[tmpK] + tokenArray[tmpK].length(); 4495 dR[lineNumber] = ColumnPosOfCurrentToken; 4496 if (myequals(tokenArray[tmpK], c_char_right_paren) && !IsInNonFormatZone[tmpK] 4497 && brSetPrimaryIndentToCursorPosition[blockIDByToken[tmpK]]) { 4498 indentLength = brPrimaryIndentBeforBr[blockIDByToken[tmpK]]; 4499 } 4500 if (increaseAfterToken > 0) { 4501 indentLength += increaseAfterToken * currentIndentSize; 4502 } 4503 if (reduceAfterToken > 0) { 4504 indentLength -= reduceAfterToken * currentIndentSize; 4505 } 4506 if (indentLength < 0) { 4507 indentLength = 0; 4508 } 4509 if (!IsInNonFormatZone[tmpK]) { 4510 if (!tokenArray[tmpK].isEmpty()) { 4511 prevprevToken = prevToken2; 4512 prevToken1 = tokenArray[tmpK]; 4513 prevToken2 = tokenArray[tmpK]; 4514 prevTokenPos1 = tmpK; 4515 prevTokenPos2 = tmpK; 4516 if (!myequals(tokenArray[tmpK], c_char_left_paren)) { 4517 prev_no_left_bracket_token = tokenArray[tmpK]; 4518 } 4519 } 4520 } else { 4521 prevToken2 = ""; 4522 prevprevToken = ""; 4523 } 4524 prevTokenLinebreakAfter = linebreakAfter; 4525 } 4526 4527 public void processDB2Linebreak() { 4528 if (equalsIgnoreCase(tokenArray[tmpK], c_char_left_paren)) { 4529 if (equalsIgnoreCase(prev_no_left_bracket_token, c_object) 4530 || equalsIgnoreCase(prev_no_left_bracket_token, c_record)) { 4531 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 4532 linebreakAfter = 1; 4533 linebreakBefore = 1; 4534 increaseAfterToken = 1; 4535 } 4536 if (!includeStr(c_predefined_sep + prevToken_nonEmpty(tmpK) + c_predefined_sep, datatypeStr) 4537 && (equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], c_procedure_header) 4538 || equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], 4539 c_function_header) 4540 || equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], 4541 c_package_header))) { 4542 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 4543 brSetPrimaryIndentToCursorPosition[blockIDByToken[tmpK]] = true; 4544 } 4545 } 4546 if (equalsIgnoreCase(tokenArray[tmpK], c_create)) { 4547 setSPKeyword(tokenArray[tmpK]); 4548 increaseAfterToken = 1; 4549 linebreakBefore = 1; 4550 if (matchByPattern2(regex_create_or_replace_procedure, true, tmpK, 4, c_numberOfSpace_1)) { 4551 setSPKeyword(c_procedure_header); 4552 linebreakAfter = 1; 4553 } 4554 if (matchByPattern2(regex_create_or_replace_package, true, tmpK, 4, c_numberOfSpace_1)) { 4555 setSPKeyword(c_package_header); 4556 linebreakAfter = 1; 4557 } 4558 if (matchByPattern2(regex_create_or_replace_function, true, tmpK, 4, c_numberOfSpace_1)) { 4559 setSPKeyword(c_function_header); 4560 linebreakAfter = 1; 4561 } 4562 if (matchByPattern2(regex_create_or_replace_procedure, true, tmpK, 4, c_numberOfSpace_1)) { 4563 setSPKeyword(c_procedure_header); 4564 linebreakAfter = 1; 4565 } 4566 if (matchByPattern2(regex_create_or_replace_synonym, true, tmpK, 4, c_numberOfSpace_1)) { 4567 setSPKeyword(c_create_synonym); 4568 } 4569 if (matchByPattern2(regex_create_or_replace_package, true, tmpK, 4, c_numberOfSpace_1)) { 4570 setSPKeyword(c_package_header); 4571 linebreakAfter = 1; 4572 } 4573 if (matchByPattern2(regex_create_or_replace_function, true, tmpK, 4, c_numberOfSpace_1)) { 4574 setSPKeyword(c_function_header); 4575 linebreakAfter = 1; 4576 } 4577 } 4578 if (equalsIgnoreCase(tokenArray[tmpK], c_drop_procedure)) { 4579 setSPKeyword(c_procedure_header); 4580 } 4581 if (equalsIgnoreCase(tokenArray[tmpK], c_function)) { 4582 setSPKeyword(c_function_header); 4583 if (reduceLevelRelatedB3) { 4584 reducedLevel = 1; 4585 reduceLevelRelatedB1 = false; 4586 } 4587 reduceLevelRelatedB3 = true; 4588 increaseAfterToken = 1; 4589 if (!equalsIgnoreCase(prevToken1, c_member) 4590 && !equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 4591 linebreakBefore = 1; 4592 } 4593 if (reduceLevelRelatedB1) { 4594 reducedLevel = 1; 4595 reduceLevelRelatedB1 = false; 4596 } 4597 } 4598 if (equalsIgnoreCase(tokenArray[tmpK], c_object) || equalsIgnoreCase(tokenArray[tmpK], c_record)) { 4599 setSPKeyword(tokenArray[tmpK]); 4600 increaseAfterToken = 1; 4601 linebreakBefore = 1; 4602 } 4603 if (myequals(tokenArray[tmpK], ",") && brWithCommaLineBreak[blockIDByToken[tmpK]]) { 4604 if (linebreakAfterComma) { 4605 linebreakAfter = 1; 4606 } 4607 if (linebreakBeforeComma) { 4608 linebreakBefore = 1; 4609 } 4610 } 4611 if (equalsIgnoreCase(tokenArray[tmpK], "||")) { 4612 if (linebreakAfterConcatenations) { 4613 linebreakAfter = 1; 4614 } 4615 if (linebreakBeforeConcatenations) { 4616 linebreakBefore = 1; 4617 } 4618 } 4619 if (equalsIgnoreCase(tokenArray[tmpK], c_procedure)) { 4620 setSPKeyword(c_procedure_header); 4621 increaseAfterToken = 1; 4622 reducedLevel = 1; 4623 if (!equalsIgnoreCase(prevToken1, c_member) 4624 && !equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 4625 linebreakBefore = 1; 4626 } 4627 if (reduceLevelRelatedB1) { 4628 reducedLevel = 1; 4629 reduceLevelRelatedB1 = false; 4630 } 4631 } 4632 if (equalsIgnoreCase(tokenArray[tmpK], c_package) 4633 || startsWith(tokenArray[tmpK].toLowerCase(), c_package + c_char_dot)) { 4634 setSPKeyword(c_package_header); 4635 increaseAfterToken = 1; 4636 reducedLevel = 1; 4637 if (!equalsIgnoreCase(prevToken1, c_member) 4638 && !equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 4639 linebreakBefore = 1; 4640 } 4641 if (reduceLevelRelatedB1) { 4642 reducedLevel = 1; 4643 reduceLevelRelatedB1 = false; 4644 } 4645 } 4646 if (equalsIgnoreCase(tokenArray[tmpK], c_if)) { 4647 setSPKeyword(tokenArray[tmpK]); 4648 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 4649 increaseAfterToken = 1; 4650 linebreakBefore = 1; 4651 } 4652 } 4653 if (equalsIgnoreCase(tokenArray[tmpK], c_type)) { 4654 setSPKeyword(tokenArray[tmpK]); 4655 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_declare)) { 4656 reducedLevel = 1; 4657 } 4658 } 4659 if (equalsIgnoreCase(tokenArray[tmpK], c_loop)) { 4660 setSPKeyword(tokenArray[tmpK]); 4661 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 4662 increaseAfterToken = 1; 4663 linebreakAfter = 1; 4664 linebreakBefore = 1; 4665 } 4666 } 4667 if (equalsIgnoreCase(tokenArray[tmpK], c_declare)) { 4668 setSPKeyword(tokenArray[tmpK]); 4669 } 4670 if (equalsIgnoreCase(tokenArray[tmpK], c_return)) { 4671 setSPKeyword(tokenArray[tmpK]); 4672 linebreakBefore = 1; 4673 } 4674 if (equalsIgnoreCase(tokenArray[tmpK], c_begin)) { 4675 setSPKeyword(tokenArray[tmpK]); 4676 increaseAfterToken = 1; 4677 if (reduceLevelRelatedB1) { 4678 reduceLevelRelatedB1 = false; 4679 } 4680 if (!equalsIgnoreCase(prevToken1, c_then) && !equalsIgnoreCase(prevToken1, c_else) 4681 && !equalsIgnoreCase(prevToken1, c_elsif) && !equalsIgnoreCase(prevToken1, c_elseif)) { 4682 reducedLevel = 1; 4683 } 4684 linebreakAfter = 1; 4685 linebreakBefore = 1; 4686 } 4687 if ((equalsIgnoreCase(tokenArray[tmpK], c_is) || equalsIgnoreCase(tokenArray[tmpK], c_as)) 4688 && !equalsIgnoreCase(nextSolidToken(tmpK), c_null) && !equalsIgnoreCase(nextSolidToken(tmpK), c_not) 4689 && !equalsIgnoreCase(brPrecedingT[blockIDByToken[tmpK]], c_cast)) { 4690 setSPKeyword(tokenArray[tmpK]); 4691 reduceLevelRelatedB1 = true; 4692 increaseAfterToken = 1; 4693 reducedLevel = 1; 4694 linebreakAfter = 1; 4695 linebreakBefore = 1; 4696 } 4697 if (equalsIgnoreCase(tokenArray[tmpK], c_exception)) { 4698 setSPKeyword(tokenArray[tmpK]); 4699 increaseAfterToken = 1; 4700 reducedLevel = 1; 4701 linebreakAfter = 1; 4702 linebreakBefore = 1; 4703 } 4704 if (equalsIgnoreCase(tokenArray[tmpK], c_end)) { 4705 setSPKeyword(tokenArray[tmpK]); 4706 reducedLevel = 1; 4707 linebreakBefore = 1; 4708 } 4709 if (equalsIgnoreCase(tokenArray[tmpK], c_case)) { 4710 setSPKeyword(tokenArray[tmpK]); 4711 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 4712 increaseAfterToken = 1; 4713 linebreakBefore = 1; 4714 } 4715 } 4716 if (equalsIgnoreCase(tokenArray[tmpK], c_when)) { 4717 setSPKeyword(tokenArray[tmpK]); 4718 linebreakBefore = 1; 4719 increaseAfterToken = 1; 4720 reducedLevel = 1; 4721 } 4722 if (equalsIgnoreCase(tokenArray[tmpK], c_for)) { 4723 setSPKeyword(tokenArray[tmpK]); 4724 } 4725 if (equalsIgnoreCase(tokenArray[tmpK], c_then)) { 4726 setSPKeyword(tokenArray[tmpK]); 4727 linebreakAfter = 1; 4728 } 4729 if (equalsIgnoreCase(tokenArray[tmpK], c_in) || equalsIgnoreCase(tokenArray[tmpK], c_out) 4730 || equalsIgnoreCase(tokenArray[tmpK], c_inout)) { 4731 setSPKeyword(tokenArray[tmpK]); 4732 } 4733 if (equalsIgnoreCase(tokenArray[tmpK], c_else)) { 4734 setSPKeyword(tokenArray[tmpK]); 4735 linebreakBefore = 1; 4736 linebreakAfter = 1; 4737 increaseAfterToken = 1; 4738 reducedLevel = 1; 4739 } 4740 if (equalsIgnoreCase(tokenArray[tmpK], c_elseif) || equalsIgnoreCase(tokenArray[tmpK], c_elsif)) { 4741 setSPKeyword(tokenArray[tmpK]); 4742 linebreakBefore = 1; 4743 linebreakAfter = 1; 4744 increaseAfterToken = 1; 4745 reducedLevel = 1; 4746 } 4747 if (myequals(tokenArray[tmpK], c_char_semicolon)) { 4748 setSPKeyword(tokenArray[tmpK]); 4749 linebreakAfter = 1; 4750 } 4751 } 4752 4753 public void processLinebreak() { 4754 boolean flag = false; 4755 4756 if (tmpK == 1) { 4757 linebreakBefore = 1; 4758 } 4759 if (IsInSmallSQL[tmpK] && (linebreakBefore > 0) && !tNbrcY[tmpK] 4760 && (!isStartLineComment[tmpK] || (tNbrOfPrecedingLinebreak[tmpK] <= 0)) 4761 && !IsEndComment[posOfPrevToken_nonEmpty(tmpK)]) { 4762 linebreakBefore = 0; 4763 } 4764 if (startTokenOfMasterSQL[tmpK] && !IsInNonFormatZone[tmpK] && SQLStartWithBracket[SQLIDByToken[tmpK]] 4765 && !linebreakAfterLeftBracketsOfSubSelect) { 4766 linebreakBefore = 0; 4767 } 4768 if ((linebreakBefore > 0) && (prevTokenLinebreakAfter > linebreakBefore)) { 4769 linebreakBefore = prevTokenLinebreakAfter; 4770 } 4771 if (CanSetLineBreakAfter[tmpK] && !breakAfterMasterKeyword) { 4772 linebreakAfter = 0; 4773 } 4774 if (IsInJOIN[tmpK] && !IsStartJOIN[tmpK] && ((linebreakAfter > 0) || (linebreakBefore > 0)) 4775 && !breakBeforeONkeyword && !IsInComment[tmpK]) { 4776 linebreakAfter = 0; 4777 if (!IsStartJOIN[posOfPrevToken_nonEmpty(tmpK)]) { 4778 linebreakBefore = 0; 4779 } 4780 } 4781 if (myequals(tokenArray[tmpK], c_char_left_paren) && !IsInComment[tmpK]) { 4782 flag = false; 4783 if (includeStr(c_predefined_sep + prevToken_nonEmpty(tmpK) + c_predefined_sep, fromWhereMoreKeywordsStr)) { 4784 flag = true; 4785 } 4786 if (brSurroundsSQL[blockIDByToken[tmpK]]) { 4787 if (linebreakAfterLeftBracketsOfSubSelect) { 4788 linebreakAfter = 1; 4789 } else { 4790 linebreakAfter = 0; 4791 } 4792 if (!flag) { 4793 if (linebreakBeforeStartParenthesisOfSubquery) { 4794 linebreakBefore = 1; 4795 } else { 4796 linebreakBefore = 0; 4797 } 4798 if (!linebreakAfterComma && myequals(prevNonCommentToken(tmpK), c_char_coma)) { 4799 linebreakBefore = 0; 4800 } 4801 } 4802 if (brAfterSQLMasterKeyword[blockIDByToken[tmpK]]) { 4803 if (!flag) { 4804 linebreakBefore = 1; 4805 } 4806 linebreakAfter = 1; 4807 } 4808 if (brAfterInsertValuesKeyword[blockIDByToken[tmpK]]) { 4809 if (linebreakBeforeStartParenthesisOfInsert && !flag) { 4810 linebreakBefore = 1; 4811 } 4812 if (linebreakAfterStartParenthesisOfInsert) { 4813 linebreakAfter = 1; 4814 } 4815 } 4816 if (brSurroundsParams[blockIDByToken[tmpK]]) { 4817 if (SPLinebreakAfterStartParenthesisofParameters) { 4818 linebreakAfter = 1; 4819 } else { 4820 linebreakAfter = 0; 4821 } 4822 if (SPLinebreakBeforeStartParenthesisofParameters) { 4823 linebreakBefore = 1; 4824 } else { 4825 linebreakBefore = 0; 4826 } 4827 } 4828 if (brSurroundsCase[blockIDByToken[tmpK]] && !linebreakForCase) { 4829 linebreakAfter = 0; 4830 if (!flag) { 4831 linebreakBefore = 0; 4832 } 4833 } 4834 if (brSurroundsCase[blockIDByToken[tmpK]] && linebreakForCase) { 4835 if (linebreakAfterStartParenthesisOfCase) { 4836 linebreakAfter = 1; 4837 } else { 4838 linebreakAfter = 0; 4839 } 4840 if (!flag) { 4841 if (linebreakBeforeStartParenthesisOfCase) { 4842 linebreakBefore = 1; 4843 } else { 4844 linebreakBefore = 0; 4845 } 4846 } 4847 } 4848 if (brSurroundsCondition[blockIDByToken[tmpK]]) { 4849 if ((IsInaSQL[tmpK] && linebreakAfterLeftBracketOfACondition) 4850 || (!IsInaSQL[tmpK] && SPLinebreakAfterStartParenthesisofCondition)) { 4851 linebreakAfter = 1; 4852 } else { 4853 linebreakAfter = 0; 4854 } 4855 if ((!IsInCase[tmpK] && !flag) && ((IsInaSQL[tmpK] && linebreakBeforeStartParenthesisOfCondition) 4856 || (!IsInaSQL[tmpK] && SPLinebreakBeforeStartParenthesisofCondition))) { 4857 linebreakBefore = 1; 4858 } else if (!equalsIgnoreCase(prevToken_nonEmpty(tmpK), c_and) 4859 && !equalsIgnoreCase(prevToken_nonEmpty(tmpK), c_or)) { 4860 linebreakBefore = 0; 4861 } 4862 if (IsInCase[tmpK] && (!linebreakForCase || !linebreakBeforeCaseWhen)) { 4863 linebreakBefore = 0; 4864 linebreakAfter = 0; 4865 } 4866 } 4867 } 4868 } 4869 4870 if (myequals(tokenArray[tmpK], c_char_right_paren) && !IsInComment[tmpK]) { 4871 if (brSurroundsSQL[blockIDByToken[tmpK]]) { 4872 if (linebreakBeforeEndParenthesisOfSubquery) { 4873 linebreakBefore = 1; 4874 } else { 4875 linebreakBefore = 0; 4876 } 4877 if (linebreakAfterEndParenthesisOfSubquery) { 4878 linebreakAfter = 1; 4879 } else { 4880 linebreakAfter = 0; 4881 } 4882 } 4883 if (brAfterSQLMasterKeyword[blockIDByToken[tmpK]]) { 4884 linebreakBefore = 1; 4885 linebreakAfter = 1; 4886 } 4887 if (brAfterInsertValuesKeyword[blockIDByToken[tmpK]]) { 4888 if (linebreakBeforeEndParenthesisOfInsert) { 4889 linebreakBefore = 1; 4890 } 4891 if (linebreakAfterEndParenthesisOfInsert) { 4892 linebreakAfter = 1; 4893 } 4894 } 4895 if (brSurroundsCondition[blockIDByToken[tmpK]]) { 4896 if ((IsInaSQL[tmpK] && linebreakBeforeEndParenthesisOfCondition) 4897 || (!IsInaSQL[tmpK] && SPLinebreakBeforeEndParenthesisofCondition)) { 4898 linebreakBefore = 1; 4899 } else { 4900 linebreakBefore = 0; 4901 } 4902 if ((IsInaSQL[tmpK] && linebreakAfterEndParenthesisOfCondition) 4903 || (!IsInaSQL[tmpK] && SPLinebreakAfterEndParenthesisofCondition)) { 4904 linebreakAfter = 1; 4905 } else { 4906 linebreakAfter = 0; 4907 } 4908 } 4909 if (brSurroundsParams[blockIDByToken[tmpK]]) { 4910 if (SPLinebreakBeforeEndParenthesisofParameters) { 4911 linebreakBefore = 1; 4912 } else { 4913 linebreakBefore = 0; 4914 } 4915 } 4916 if (brSurroundsCase[blockIDByToken[tmpK]] && linebreakForCase) { 4917 if (linebreakBeforeEndParenthesisOfCase) { 4918 linebreakBefore = 1; 4919 } else { 4920 linebreakBefore = 0; 4921 } 4922 if (linebreakAfterEndParenthesisOfCase) { 4923 linebreakAfter = 1; 4924 } else { 4925 linebreakAfter = 0; 4926 } 4927 } 4928 } 4929 if (IsInCase[tmpK]) { 4930 if (!linebreakForCase) { 4931 if (tNbrdn[tmpK]) { 4932 linebreakAfter = 0; 4933 } 4934 if (tNbrdn[tmpK] && (!linebreakAfterComma || !equalsIgnoreCase(tokenArray[tmpK], c_case) 4935 || !myequals(prevToken_nonEmpty(tmpK), c_char_coma))) { 4936 linebreakBefore = 0; 4937 } 4938 if (equalsIgnoreCase(tokenArray[tmpK], c_and) || equalsIgnoreCase(tokenArray[tmpK], c_or)) { 4939 linebreakBefore = 0; 4940 } 4941 } 4942 if (linebreakForCase) { 4943 if (tNbrdn[tmpK] && equalsIgnoreCase(tokenArray[tmpK], c_when) && !linebreakBeforeCaseWhen) { 4944 linebreakBefore = 0; 4945 } 4946 if (tNbrdn[tmpK] && equalsIgnoreCase(tokenArray[tmpK], c_then) && !linebreakBeforeCaseThen) { 4947 linebreakBefore = 0; 4948 } 4949 if (tNbrdn[tmpK] && equalsIgnoreCase(tokenArray[tmpK], c_else) && !linebreakBeforeCaseElse) { 4950 linebreakBefore = 0; 4951 } 4952 if ((equalsIgnoreCase(tokenArray[tmpK], c_and) || equalsIgnoreCase(tokenArray[tmpK], c_or)) 4953 && !linebreakBeforeCaseANDOR) { 4954 linebreakBefore = 0; 4955 } 4956 } 4957 if (equalsIgnoreCase(tokenArray[tmpK], c_case) && linebreakBeforeComma 4958 && myequals(prevToken_nonComment_noEmpty(tmpK), c_char_coma)) { 4959 linebreakBefore = 0; 4960 } 4961 } 4962 } 4963 4964 public void processMySQLLinebreak() { 4965 if (equalsIgnoreCase(tokenArray[tmpK], c_char_left_paren)) { 4966 if (equalsIgnoreCase(prev_no_left_bracket_token, c_object) 4967 || equalsIgnoreCase(prev_no_left_bracket_token, c_record)) { 4968 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 4969 linebreakAfter = 1; 4970 linebreakBefore = 1; 4971 increaseAfterToken = 1; 4972 } 4973 if (!includeStr(c_predefined_sep + prevToken_nonEmpty(tmpK) + c_predefined_sep, datatypeStr) 4974 && (equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], c_procedure_header) 4975 || equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], 4976 c_function_header) 4977 || equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], 4978 c_package_header))) { 4979 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 4980 brSetPrimaryIndentToCursorPosition[blockIDByToken[tmpK]] = true; 4981 } 4982 } 4983 if (equalsIgnoreCase(tokenArray[tmpK], c_create)) { 4984 setSPKeyword(tokenArray[tmpK]); 4985 increaseAfterToken = 1; 4986 linebreakBefore = 1; 4987 if (matchByPattern2(regex_create_or_replace_procedure_mysql, true, tmpK, 3, c_numberOfSpace_1)) { 4988 setSPKeyword(c_procedure_header); 4989 linebreakAfter = 1; 4990 } 4991 if (matchByPattern2(regex_create_or_replace_package_mysql, true, tmpK, 3, c_numberOfSpace_1)) { 4992 setSPKeyword(c_package_header); 4993 linebreakAfter = 1; 4994 } 4995 if (matchByPattern2(regex_create_or_replace_function_mysql, true, tmpK, 3, c_numberOfSpace_1)) { 4996 setSPKeyword(c_function_header); 4997 linebreakAfter = 1; 4998 } 4999 } 5000 if (equalsIgnoreCase(tokenArray[tmpK], c_function)) { 5001 setSPKeyword(c_function_header); 5002 if (reduceLevelRelatedB3) { 5003 reducedLevel = 1; 5004 reduceLevelRelatedB1 = false; 5005 } 5006 reduceLevelRelatedB3 = true; 5007 increaseAfterToken = 1; 5008 if (!equalsIgnoreCase(prevToken1, c_member) 5009 && !equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5010 linebreakBefore = 1; 5011 } 5012 if (reduceLevelRelatedB1) { 5013 reducedLevel = 1; 5014 reduceLevelRelatedB1 = false; 5015 } 5016 } 5017 if (equalsIgnoreCase(tokenArray[tmpK], c_object) || equalsIgnoreCase(tokenArray[tmpK], c_record)) { 5018 setSPKeyword(tokenArray[tmpK]); 5019 increaseAfterToken = 1; 5020 linebreakBefore = 1; 5021 } 5022 if (myequals(tokenArray[tmpK], ",") && brWithCommaLineBreak[blockIDByToken[tmpK]]) { 5023 if (linebreakAfterComma) { 5024 linebreakAfter = 1; 5025 } 5026 if (linebreakBeforeComma) { 5027 linebreakBefore = 1; 5028 } 5029 } 5030 if (equalsIgnoreCase(tokenArray[tmpK], "||")) { 5031 if (linebreakAfterConcatenations) { 5032 linebreakAfter = 1; 5033 } 5034 if (linebreakBeforeConcatenations) { 5035 linebreakBefore = 1; 5036 } 5037 } 5038 if (equalsIgnoreCase(tokenArray[tmpK], c_procedure)) { 5039 setSPKeyword(c_procedure_header); 5040 increaseAfterToken = 1; 5041 reducedLevel = 1; 5042 if (!equalsIgnoreCase(prevToken1, c_member) 5043 && !equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5044 linebreakBefore = 1; 5045 } 5046 if (reduceLevelRelatedB1) { 5047 reducedLevel = 1; 5048 reduceLevelRelatedB1 = false; 5049 } 5050 } 5051 if (equalsIgnoreCase(tokenArray[tmpK], c_package) 5052 || startsWith(tokenArray[tmpK].toLowerCase(), c_package + c_char_dot)) { 5053 setSPKeyword(c_package_header); 5054 increaseAfterToken = 1; 5055 reducedLevel = 1; 5056 if (!equalsIgnoreCase(prevToken1, c_member) 5057 && !equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5058 linebreakBefore = 1; 5059 } 5060 if (reduceLevelRelatedB1) { 5061 reducedLevel = 1; 5062 reduceLevelRelatedB1 = false; 5063 } 5064 } 5065 if (equalsIgnoreCase(tokenArray[tmpK], c_if)) { 5066 setSPKeyword(tokenArray[tmpK]); 5067 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5068 increaseAfterToken = 1; 5069 linebreakBefore = 1; 5070 } 5071 } 5072 if (equalsIgnoreCase(tokenArray[tmpK], c_repeat)) { 5073 setSPKeyword(tokenArray[tmpK]); 5074 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5075 increaseAfterToken = 1; 5076 linebreakBefore = 1; 5077 } 5078 } 5079 if (equalsIgnoreCase(tokenArray[tmpK], c_type)) { 5080 setSPKeyword(tokenArray[tmpK]); 5081 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_declare)) { 5082 reducedLevel = 1; 5083 } 5084 } 5085 if (equalsIgnoreCase(tokenArray[tmpK], c_loop)) { 5086 setSPKeyword(tokenArray[tmpK]); 5087 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5088 increaseAfterToken = 1; 5089 linebreakAfter = 1; 5090 linebreakBefore = 1; 5091 } 5092 } 5093 if (equalsIgnoreCase(tokenArray[tmpK], c_declare)) { 5094 setSPKeyword(tokenArray[tmpK]); 5095 } 5096 if (equalsIgnoreCase(tokenArray[tmpK], c_return)) { 5097 setSPKeyword(tokenArray[tmpK]); 5098 linebreakBefore = 1; 5099 } 5100 if (equalsIgnoreCase(tokenArray[tmpK], c_begin)) { 5101 setSPKeyword(tokenArray[tmpK]); 5102 increaseAfterToken = 1; 5103 if (reduceLevelRelatedB1) { 5104 reduceLevelRelatedB1 = false; 5105 } 5106 if (!equalsIgnoreCase(prevToken1, c_then) && !equalsIgnoreCase(prevToken1, c_else) 5107 && !equalsIgnoreCase(prevToken1, c_elsif) && !equalsIgnoreCase(prevToken1, c_elseif)) { 5108 reducedLevel = 1; 5109 } 5110 linebreakAfter = 1; 5111 linebreakBefore = 1; 5112 } 5113 if ((equalsIgnoreCase(tokenArray[tmpK], c_is) || equalsIgnoreCase(tokenArray[tmpK], c_as)) 5114 && !equalsIgnoreCase(nextSolidToken(tmpK), c_null) && !equalsIgnoreCase(nextSolidToken(tmpK), c_not) 5115 && !equalsIgnoreCase(brPrecedingT[blockIDByToken[tmpK]], c_cast)) { 5116 setSPKeyword(tokenArray[tmpK]); 5117 reduceLevelRelatedB1 = true; 5118 increaseAfterToken = 1; 5119 reducedLevel = 1; 5120 linebreakAfter = 1; 5121 linebreakBefore = 1; 5122 } 5123 if (equalsIgnoreCase(tokenArray[tmpK], c_exception)) { 5124 setSPKeyword(tokenArray[tmpK]); 5125 increaseAfterToken = 1; 5126 reducedLevel = 1; 5127 linebreakAfter = 1; 5128 linebreakBefore = 1; 5129 } 5130 if (equalsIgnoreCase(tokenArray[tmpK], c_end)) { 5131 setSPKeyword(tokenArray[tmpK]); 5132 reducedLevel = 1; 5133 linebreakBefore = 1; 5134 } 5135 if (equalsIgnoreCase(tokenArray[tmpK], c_case)) { 5136 setSPKeyword(tokenArray[tmpK]); 5137 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5138 increaseAfterToken = 1; 5139 linebreakBefore = 1; 5140 } 5141 } 5142 if (equalsIgnoreCase(tokenArray[tmpK], c_when)) { 5143 setSPKeyword(tokenArray[tmpK]); 5144 linebreakBefore = 1; 5145 increaseAfterToken = 1; 5146 reducedLevel = 1; 5147 } 5148 if (equalsIgnoreCase(tokenArray[tmpK], c_for)) { 5149 setSPKeyword(tokenArray[tmpK]); 5150 } 5151 if (equalsIgnoreCase(tokenArray[tmpK], c_then)) { 5152 setSPKeyword(tokenArray[tmpK]); 5153 linebreakAfter = 1; 5154 } 5155 if (equalsIgnoreCase(tokenArray[tmpK], c_in) || equalsIgnoreCase(tokenArray[tmpK], c_out) 5156 || equalsIgnoreCase(tokenArray[tmpK], c_inout)) { 5157 setSPKeyword(tokenArray[tmpK]); 5158 } 5159 if (equalsIgnoreCase(tokenArray[tmpK], c_else)) { 5160 setSPKeyword(tokenArray[tmpK]); 5161 linebreakBefore = 1; 5162 linebreakAfter = 1; 5163 increaseAfterToken = 1; 5164 reducedLevel = 1; 5165 } 5166 if (equalsIgnoreCase(tokenArray[tmpK], c_elseif) || equalsIgnoreCase(tokenArray[tmpK], c_elsif)) { 5167 setSPKeyword(tokenArray[tmpK]); 5168 linebreakBefore = 1; 5169 linebreakAfter = 1; 5170 increaseAfterToken = 1; 5171 reducedLevel = 1; 5172 } 5173 if (myequals(tokenArray[tmpK], c_char_semicolon)) { 5174 setSPKeyword(tokenArray[tmpK]); 5175 linebreakAfter = 1; 5176 } 5177 } 5178 5179 public void processSQLServerLinebreak() { 5180 if (equalsIgnoreCase(tokenArray[tmpK], c_char_left_paren) 5181 && !includeStr(c_predefined_sep + prevToken_nonEmpty(tmpK) + c_predefined_sep, datatypeStr) 5182 && (equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], c_procedure_header) 5183 || equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], c_function_header) 5184 || equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], 5185 c_package_header))) { 5186 brSurroundsParams[blockIDByToken[tmpK]] = true; 5187 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 5188 } 5189 if (equalsIgnoreCase(tokenArray[tmpK], c_loop)) { 5190 setSPKeyword(tokenArray[tmpK]); 5191 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5192 linebreakBefore = 1; 5193 } 5194 } 5195 if (equalsIgnoreCase(tokenArray[tmpK], c_while)) { 5196 setSPKeyword(tokenArray[tmpK]); 5197 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5198 linebreakBefore = 1; 5199 } 5200 } 5201 if (equalsIgnoreCase(tokenArray[tmpK], c_end) || equalsIgnoreCase(tokenArray[tmpK], c_end_catch) 5202 || equalsIgnoreCase(tokenArray[tmpK], c_end_tran) || equalsIgnoreCase(tokenArray[tmpK], c_end_try) 5203 || equalsIgnoreCase(tokenArray[tmpK], c_end_transaction)) { 5204 if (sqlserverb1) { 5205 setSPKeyword(tokenArray[tmpK]); 5206 reducedLevel = 2; 5207 } else { 5208 setSPKeyword(tokenArray[tmpK]); 5209 reducedLevel = 1; 5210 } 5211 linebreakBefore = 1; 5212 linebreakAfter = 1; 5213 } 5214 if (equalsIgnoreCase(tokenArray[tmpK], c_for)) { 5215 setSPKeyword(tokenArray[tmpK]); 5216 } 5217 if (equalsIgnoreCase(tokenArray[tmpK], c_case)) { 5218 setSPKeyword(tokenArray[tmpK]); 5219 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5220 increaseAfterToken = 1; 5221 linebreakBefore = 1; 5222 } 5223 } 5224 if (equalsIgnoreCase(tokenArray[tmpK], c_when)) { 5225 setSPKeyword(tokenArray[tmpK]); 5226 linebreakBefore = 1; 5227 increaseAfterToken = 1; 5228 reducedLevel = 1; 5229 } 5230 if (equalsIgnoreCase(tokenArray[tmpK], c_begin) || equalsIgnoreCase(tokenArray[tmpK], c_begin_catch) 5231 || equalsIgnoreCase(tokenArray[tmpK], c_begin_try)) { 5232 setSPKeyword(tokenArray[tmpK]); 5233 increaseAfterToken = 1; 5234 linebreakBefore = 1; 5235 linebreakAfter = 1; 5236 } 5237 if (equalsIgnoreCase(tokenArray[tmpK], c_begin_tran) 5238 || equalsIgnoreCase(tokenArray[tmpK], c_begin_transaction)) { 5239 setSPKeyword(tokenArray[tmpK]); 5240 linebreakBefore = 1; 5241 } 5242 if (equalsIgnoreCase(tokenArray[tmpK], c_if)) { 5243 setSPKeyword(tokenArray[tmpK]); 5244 increaseAfterToken = 0; 5245 linebreakBefore = 1; 5246 } 5247 if (equalsIgnoreCase(tokenArray[tmpK], c_then)) { 5248 setSPKeyword(tokenArray[tmpK]); 5249 linebreakAfter = 1; 5250 } 5251 if (equalsIgnoreCase(tokenArray[tmpK], c_else)) { 5252 setSPKeyword(tokenArray[tmpK]); 5253 increaseAfterToken = 0; 5254 reducedLevel = 0; 5255 linebreakBefore = 1; 5256 } 5257 if (equalsIgnoreCase(tokenArray[tmpK], c_elseif) || equalsIgnoreCase(tokenArray[tmpK], c_elsif)) { 5258 setSPKeyword(tokenArray[tmpK]); 5259 linebreakBefore = 1; 5260 linebreakAfter = 0; 5261 increaseAfterToken = 1; 5262 reducedLevel = 1; 5263 } 5264 if (equalsIgnoreCase(tokenArray[tmpK], c_type)) { 5265 setSPKeyword(tokenArray[tmpK]); 5266 reducedLevel = 1; 5267 } 5268 if ((equalsIgnoreCase(tokenArray[tmpK], c_is) || equalsIgnoreCase(tokenArray[tmpK], c_as)) 5269 && !startsWith(prevToken_nonComment_noEmpty(tmpK), c_predefined_sep) 5270 && !equalsIgnoreCase(brPrecedingT[blockIDByToken[tmpK]], c_cast) 5271 && (equalsIgnoreCase(BelongsToSPKeyword[tmpK], c_procedure_header) 5272 || equalsIgnoreCase(BelongsToSPKeyword[tmpK], c_function_header) 5273 || equalsIgnoreCase(BelongsToSPKeyword[tmpK], c_package_header))) { 5274 setSPKeyword(tokenArray[tmpK]); 5275 reduceLevelRelatedB1 = true; 5276 increaseAfterToken = 1; 5277 linebreakAfter = 1; 5278 linebreakBefore = 1; 5279 } 5280 if (startsWith(tokenArray[tmpK], c_char_at) && !brSurroundsParams[blockIDByToken[tmpK]] 5281 && equalsIgnoreCase(BelongsToSPKeyword[tmpK], c_procedure_header)) { 5282 if (!sqlserverb1) { 5283 sqlserverb1 = true; 5284 increasedLevel = 1; 5285 } 5286 linebreakBefore = 1; 5287 } 5288 if (equalsIgnoreCase(tokenArray[tmpK], c_open)) { 5289 // Pattern pattern := Pattern.compile('open +\w+ +cursor +for', 2); 5290 if (matchByPattern2(regex_open_cursor_for, true, tmpK, 3, c_numberOfSpace_1)) { 5291 linebreakAfter = 1; 5292 setFalseCanGetLineBreakAfter(); 5293 } 5294 } 5295 if (equalsIgnoreCase(tokenArray[tmpK], c_declare)) { 5296 // Pattern pattern1 := 'Pattern.compile("Declare *\w+ *((insensitive|scroll) 5297 // *)*cursor *for", 2)'; 5298 if (matchByPattern2(regex_declare_cursor_for, true, tmpK, 5, c_numberOfSpace_1)) { 5299 linebreakAfter = 1; 5300 setFalseCanGetLineBreakAfter(); 5301 } 5302 // pattern1 := 'Pattern.compile("Declare *\w+ *cursor *((LOCAL|GLOBAL) 5303 // *)*((FORWARD_ONLY|SCROLL) *)*((STATIC|KEYSET|DYNAMIC|FAST_FORWARD) 5304 // *)*((READ_ONLY|SCROLL_LOCKS|OPTIMISTIC) *)*((TYPE_WARNING) *)*for", 2)'; 5305 if (matchByPattern2(regex_declare_cursor_for2, true, tmpK, 9, c_numberOfSpace_1)) { 5306 linebreakAfter = 1; 5307 setFalseCanGetLineBreakAfter(); 5308 } 5309 } 5310 if (equalsIgnoreCase(tokenArray[tmpK], c_cursor)) { 5311 setSPKeyword(tokenArray[tmpK]); 5312 reduceAfterRelatedB1 = true; 5313 increaseAfterToken = 1; 5314 linebreakBefore = 1; 5315 } 5316 if (equalsIgnoreCase(tokenArray[tmpK], c_exception) && !myequals(nextSolidToken(tmpK), c_char_semicolon)) { 5317 setSPKeyword(tokenArray[tmpK]); 5318 linebreakAfter = 1; 5319 linebreakBefore = 1; 5320 } 5321 if (equalsIgnoreCase(tokenArray[tmpK], c_in)) { 5322 setSPKeyword(tokenArray[tmpK]); 5323 } 5324 if (equalsIgnoreCase(tokenArray[tmpK], c_rollback_transaction)) { 5325 setSPKeyword(tokenArray[tmpK]); 5326 linebreakBefore = 1; 5327 linebreakAfter = 1; 5328 } 5329 if (equalsIgnoreCase(tokenArray[tmpK], c_open)) { 5330 setSPKeyword(tokenArray[tmpK]); 5331 linebreakBefore = 1; 5332 eb1 = 2; 5333 ec1 = true; 5334 } 5335 if (equalsIgnoreCase(tokenArray[tmpK], c_Close) || equalsIgnoreCase(tokenArray[tmpK], c_deallocate)) { 5336 setSPKeyword(tokenArray[tmpK]); 5337 linebreakBefore = 1; 5338 eb1 = 2; 5339 ec1 = true; 5340 } 5341 if (equalsIgnoreCase(tokenArray[tmpK], c_print) || equalsIgnoreCase(tokenArray[tmpK], c_raiserror) 5342 || equalsIgnoreCase(tokenArray[tmpK], c_exec) || equalsIgnoreCase(tokenArray[tmpK], c_execute)) { 5343 setSPKeyword(tokenArray[tmpK]); 5344 sqlserverMasterKeyRelatedBoolean = true; 5345 sqlserverMasterKeyRelatedLevel = bracketsInBlock[blockIDByToken[tmpK]]; 5346 sqlserverb1 = false; 5347 linebreakBefore = 1; 5348 if (equalsIgnoreCase(tokenArray[tmpK], c_exec) || equalsIgnoreCase(tokenArray[tmpK], c_execute)) { 5349 if (matchByPattern2(regex_exec, true, tmpK, 1, "1")) { 5350 linebreakAfter = 1; 5351 increaseAfterToken = 1; 5352 setFalseCanGetLineBreakAfter(); 5353 sqlserverb1 = true; 5354 } 5355 } 5356 } 5357 if (equalsIgnoreCase(tokenArray[tmpK], c_with_execute_as)) { 5358 setSPKeyword(tokenArray[tmpK]); 5359 linebreakBefore = 1; 5360 } 5361 if (equalsIgnoreCase(tokenArray[tmpK], c_grant_execute) 5362 || equalsIgnoreCase(tokenArray[tmpK], c_create_procedure) 5363 || equalsIgnoreCase(tokenArray[tmpK], c_create_proc) 5364 || equalsIgnoreCase(tokenArray[tmpK], c_drop_procedure) 5365 || equalsIgnoreCase(tokenArray[tmpK], c_create_function) 5366 || equalsIgnoreCase(tokenArray[tmpK], c_alter_function) 5367 || equalsIgnoreCase(tokenArray[tmpK], c_alter_procedure) 5368 || equalsIgnoreCase(tokenArray[tmpK], c_alter_proc)) { 5369 setSPKeyword(c_procedure_header); 5370 indentLength = 0; 5371 sqlserverMasterKeyRelatedBoolean = true; 5372 sqlserverMasterKeyRelatedLevel = bracketsInBlock[blockIDByToken[tmpK]]; 5373 sqlserverb1 = false; 5374 linebreakBefore = 1; 5375 increaseAfterToken = 0; 5376 } 5377 if (equalsIgnoreCase(tokenArray[tmpK], c_declare)) { 5378 setSPKeyword(tokenArray[tmpK]); 5379 sqlserverMasterKeyRelatedBoolean = true; 5380 sqlserverMasterKeyRelatedLevel = bracketsInBlock[blockIDByToken[tmpK]]; 5381 sqlserverb1 = false; 5382 linebreakBefore = 1; 5383 linebreakAfter = 0; 5384 } 5385 if (IsInNonFormatZone[tmpK] && matchByPattern2(regex_w, true, tmpK, 1, c_numberOfSpace_n)) { 5386 indentLength = 0; 5387 } 5388 if (equalsIgnoreCase(tokenArray[tmpK], c_set)) { 5389 setSPKeyword(tokenArray[tmpK]); 5390 sqlserverMasterKeyRelatedBoolean = true; 5391 sqlserverMasterKeyRelatedLevel = bracketsInBlock[blockIDByToken[tmpK]]; 5392 sqlserverb1 = false; 5393 linebreakBefore = 1; 5394 } 5395 if (equalsIgnoreCase(tokenArray[tmpK], c_return) || equalsIgnoreCase(tokenArray[tmpK], c_returns)) { 5396 setSPKeyword(tokenArray[tmpK]); 5397 linebreakBefore = 1; 5398 } 5399 if (equalsIgnoreCase(tokenArray[tmpK], c_go)) { 5400 setSPKeyword(tokenArray[tmpK]); 5401 indentLength = 0; 5402 linebreakBefore = 1; 5403 linebreakAfter = 1; 5404 } 5405 if (equalsIgnoreCase(tokenArray[tmpK], c_return) || equalsIgnoreCase(tokenArray[tmpK], c_commit)) { 5406 setSPKeyword(tokenArray[tmpK]); 5407 linebreakBefore = 1; 5408 linebreakAfter = 0; 5409 } 5410 if (equalsIgnoreCase(tokenArray[tmpK], c_or) || equalsIgnoreCase(tokenArray[tmpK], c_and)) { 5411 if (SPLinebreakAfterANDORofCondition) { 5412 linebreakAfter = 1; 5413 } 5414 if (SPLinebreakBeforeANDORofCondition) { 5415 linebreakBefore = 1; 5416 } 5417 } 5418 if (myequals(tokenArray[tmpK], c_char_coma)) { 5419 if (sqlserverMasterKeyRelatedBoolean 5420 && (bracketsInBlock[blockIDByToken[tmpK]] == sqlserverMasterKeyRelatedLevel)) { 5421 if (linebreakAfterComma) { 5422 linebreakAfter = 1; 5423 if (!sqlserverb1) { 5424 increaseAfterToken = 1; 5425 sqlserverb1 = true; 5426 } 5427 } 5428 if (linebreakBeforeComma) { 5429 linebreakBefore = 1; 5430 if (!sqlserverb1) { 5431 increasedLevel = 1; 5432 sqlserverb1 = true; 5433 } 5434 } 5435 } 5436 if (brWithCommaLineBreak[blockIDByToken[tmpK]]) { 5437 linebreakAfter = 1; 5438 } 5439 } 5440 if (myequals(tokenArray[tmpK], c_char_semicolon)) { 5441 setSPKeyword(tokenArray[tmpK]); 5442 linebreakBefore = 0; 5443 linebreakAfter = 1; 5444 } 5445 } 5446 5447 public void unknownMethod3() { 5448 int i1 = ColumnPosOfCurrentToken + tokenArray[tmpK].length() + tNbrOfPrecedingBlanks[tmpK] 5449 + output_end_of_each_line.length(); 5450 if (tokenArray[tmpK].equals(c_char_left_paren)) { 5451 i1 += nextSolidToken(tmpK).length() + tNbrOfPrecedingBlanks[skipToNextNonEmptyToken(tmpK)]; 5452 } 5453 if (!((i1 <= maxLineWidth) || formatSQLOn1Line)) { 5454 if (linebreakBefore == 0) { 5455 linebreakBefore = 1; 5456 } 5457 tNbrOfPrecedingBlanks[tmpK] = 0; 5458 if (!(isInlineComment[tmpK] || tokenArray[tmpK].startsWith("--"))) { 5459 tokenArray[tmpK] = "-- " + tokenArray[tmpK]; 5460 } 5461 } 5462 } 5463 5464 public void formatLinebreak() { 5465 5466 int i1, j1; 5467 boolean flag, b; 5468 int[] iret = new int[1]; 5469 5470 for (i1 = 1; i1 <= MAX_ALIGN_TOKENS; i1++) { 5471 numsOfTokenToAlign[i1] = 0; 5472 } 5473 5474 indentLength = 0; 5475 adjustLeadingSpace = 0; 5476 currentKeyword1 = ""; 5477 prevKeyword1 = ""; 5478 lineNumber = 0; 5479 eb1 = 0; 5480 ec1 = false; 5481 prevTokenLinebreakAfter = 0; 5482 prev_no_left_bracket_token = ""; 5483 prevToken1 = ""; 5484 prevToken2 = ""; 5485 prevprevToken = ""; 5486 prevTokenPos2 = 0; 5487 prevTokenPos1 = 0; 5488 reduceLevelRelatedB1 = false; 5489 reduceLevelRelatedB2 = false; 5490 reduceAfterRelatedB1 = false; 5491 reduceLevelRelatedB3 = false; 5492 sqlserverMasterKeyRelatedBoolean = false; 5493 sqlserverMasterKeyRelatedLevel = 0; 5494 sqlserverb1 = false; 5495 ColumnPosOfCurrentToken = 0; 5496 alignStyle = 0; 5497 inComment2 = false; 5498 tmpK = 1; 5499 5500 while (tmpK <= sqlTokenLen) { 5501 5502 if (tokenArray[tmpK].length() == 0) { 5503 tmpK = skipToNonEmptyToken(tmpK + 1); 5504 } 5505 5506 linebreakAfter = 0; 5507 linebreakBefore = prevTokenLinebreakAfter; 5508 reducedLevel = 0; 5509 reduceAfterToken = 0; 5510 increasedLevel = 0; 5511 increaseAfterToken = 0; 5512 5513 BelongsToSPKeyword[tmpK] = BelongsToSPKeyword[posOfPrevToken_nonEmpty(tmpK)]; 5514 bY = false; 5515 5516 if (flexibleSpaceCalculation && IsInaSQL[tmpK]) { 5517 currentIndentSize = longestMasterKeywordsInSQL[SQLIDByToken[tmpK]] + 1; 5518 } else { 5519 currentIndentSize = genericIndentSize; 5520 } 5521 5522 if (isStartBlockComment[tmpK] && linebreakBeforeBlockComment) { 5523 linebreakBefore = 1; 5524 } 5525 5526 if (isStartLineComment[tmpK]) { 5527 // inComment2 = true; 5528 // tokenArray[tmpK] = "/*" + tokenArray[tmpK]; 5529 } 5530 5531 if (isEndLineComment[tmpK] && inComment2) { 5532 // tokenArray[tmpK] = tokenArray[tmpK] + "*/"; 5533 // inComment2 = false; 5534 } 5535 5536 if (isStartLineComment[tmpK] && linebreakBefore > 0 && tNbrOfPrecedingLinebreak[tmpK] == 0) { 5537 linebreakBefore = 0; 5538 } 5539 5540 if (isStartLineComment[tmpK] && linebreakBeforeLineComment) { 5541 linebreakBefore = 1; 5542 } 5543 5544 if (tNbrOfPrecedingLinebreak[tmpK] > 0) { 5545 if (isStartLineComment[tmpK]) { 5546 linebreakBefore = 1; 5547 } 5548 if (isInBlockComment[tmpK]) { 5549 linebreakBefore = 1; 5550 } 5551 if (!IsInaSQL[tmpK] && (dbname.equals(EDbVendor.dbvsybase) || dbname.equals(EDbVendor.dbvinformix) 5552 || dbname.equals(EDbVendor.dbvmysql) || dbname.equals(EDbVendor.dbvpostgresql))) { 5553 linebreakBefore = 1; 5554 } 5555 } 5556 5557 if (!IsInNonFormatZone[tmpK] && (eb1 == 0)) { 5558 if (IsInaSQL[tmpK]) { 5559 if (myequals(tokenArray[tmpK], c_char_left_paren) 5560 && (brSurroundsSQL[blockIDByToken[tmpK]] 5561 || brAfterSQLMasterKeyword[blockIDByToken[tmpK]] 5562 || brAfterInsertValuesKeyword[blockIDByToken[tmpK]])) { 5563 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 5564 } 5565 5566 if (startTokenOfMasterSQL[tmpK]) { 5567 linebreakBefore = 1; 5568 linebreakAfter = 1; 5569 setKeyword1(); 5570 if (equalsIgnoreCase(tokenArray[tmpK], c_union) 5571 || equalsIgnoreCase(tokenArray[tmpK], c_union_all) 5572 || equalsIgnoreCase(tokenArray[tmpK], c_except) 5573 || equalsIgnoreCase(tokenArray[tmpK], c_minus) 5574 || equalsIgnoreCase(tokenArray[tmpK], c_intersect)) { 5575 if (breaksAroundUnionIntersect) { 5576 linebreakBefore = 2; 5577 linebreakAfter = 2; 5578 } 5579 } else { 5580 setTrueCanGetLineBreakAfter(); 5581 } 5582 } 5583 5584 5585 if ((includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, fromWhereMoreKeywordsStr) 5586 || equalsIgnoreCase(tokenArray[tmpK], c_set) && isUpdateToken(brSQLMasterKeyword[blockIDByToken[tmpK]])) 5587 && brSurroundsSQL[blockIDByToken[tmpK]]) { 5588 setKeyword1(); 5589 setTrueCanGetLineBreakAfter(); 5590 reducedLevel = 1; 5591 increaseAfterToken = 1; 5592 linebreakBefore = 1; 5593 linebreakAfter = 1; 5594 } 5595 5596 if (equalsIgnoreCase(tokenArray[tmpK], c_on) && IsInJOIN[tmpK]) { 5597 setKeyword1(); 5598 setTrueCanGetLineBreakAfter(); 5599 if (indentOnStatement) 5600 reducedLevel = 0; 5601 else 5602 reducedLevel = 1; 5603 increaseAfterToken = 1; 5604 linebreakBefore = 1; 5605 linebreakAfter = 1; 5606 } 5607 5608 if (equalsIgnoreCase(tokenArray[tmpK], c_set) && isUpdateToken(brSQLMasterKeyword[blockIDByToken[tmpK]])) { 5609 setKeyword1(); 5610 linebreakBefore = 1; 5611 } 5612 5613 if (equalsIgnoreCase(tokenArray[tmpK], c_next) && equalsIgnoreCase(prev_no_left_bracket_token, c_fetch)) { 5614 setKeyword1(); 5615 setTrueCanGetLineBreakAfter(); 5616 linebreakBefore = 0; 5617 linebreakAfter = 1; 5618 } 5619 5620 5621 if (equalsIgnoreCase(tokenArray[tmpK], c_between) 5622 || equalsIgnoreCase(tokenArray[tmpK], c_values) 5623 || equalsIgnoreCase(tokenArray[tmpK], c_in)) { 5624 setKeyword1(); 5625 } 5626 5627 if (equalsIgnoreCase(tokenArray[tmpK], c_as) 5628 && equalsIgnoreCase(strOfNextToken_nonComment_nonEmtpy(tmpK), c_with)) { 5629 linebreakAfter = 1; 5630 } 5631 5632 if (IsStartJOIN[tmpK]) { 5633 increaseAfterToken = 1; 5634 linebreakBefore = 1; 5635 linebreakAfter = 1; 5636 setKeyword1(); 5637 setTrueCanGetLineBreakAfter(); 5638 } 5639 5640 if (equalsIgnoreCase(tokenArray[tmpK], c_case)) { 5641 setKeyword1(); 5642 increaseAfterToken = 2; 5643 if (!myequals(prevToken_nonEmpty(tmpK), c_char_left_paren) 5644 && (linebreakAfterComma && !linebreakBeforeComma || linebreakForCase)) { 5645 linebreakBefore = 1; 5646 } 5647 tNbrdn[tmpK] = true; 5648 } 5649 5650 if (equalsIgnoreCase(tokenArray[tmpK], c_when) && IsInCase[tmpK]) { 5651 tNbrdn[tmpK] = true; 5652 setKeyword1(); 5653 linebreakBefore = 1; 5654 reducedLevel = 1; 5655 increaseAfterToken = 1; 5656 } 5657 5658 if (equalsIgnoreCase(tokenArray[tmpK], c_then) && IsInCase[tmpK]) { 5659 tNbrdn[tmpK] = true; 5660 setKeyword1(); 5661 linebreakBefore = 1; 5662 if (!indentCaseThen) { 5663 reducedLevel = 1; 5664 increaseAfterToken = 1; 5665 } 5666 } 5667 5668 if (equalsIgnoreCase(tokenArray[tmpK], c_else) && IsInCase[tmpK]) { 5669 tNbrdn[tmpK] = true; 5670 setKeyword1(); 5671 linebreakBefore = 1; 5672 if (!indentCaseElse) { 5673 reducedLevel = 1; 5674 increaseAfterToken = 1; 5675 } 5676 } 5677 5678 if (equalsIgnoreCase(tokenArray[tmpK], c_end)) { 5679 setKeyword1(); 5680 if (IsInCase[tmpK]) { 5681 tNbrdn[tmpK] = true; 5682 } 5683 linebreakBefore = 1; 5684 reducedLevel = 2; 5685 } 5686 5687 if (equalsIgnoreCase(tokenArray[tmpK], "||")) { 5688 setKeyword1(); 5689 if (linebreakAfterConcatenations) { 5690 linebreakAfter = 1; 5691 } 5692 if (linebreakBeforeConcatenations) { 5693 linebreakBefore = 1; 5694 } 5695 } 5696 5697 5698 if (equalsIgnoreCase(tokenArray[tmpK], c_or)) { 5699 setKeyword1(); 5700 if (linebreakAfterANDOR) { 5701 linebreakAfter = 1; 5702 } 5703 if (linebreakBeforeAndOr) { 5704 linebreakBefore = 1; 5705 } 5706 } 5707 5708 if (equalsIgnoreCase(tokenArray[tmpK], c_and)) { 5709 setKeyword1(); 5710 if (!equalsIgnoreCase(prevKeyword1, c_between)) { 5711 if (linebreakAfterANDOR) { 5712 linebreakAfter = 1; 5713 } 5714 if (linebreakBeforeAndOr) { 5715 linebreakBefore = 1; 5716 } 5717 } 5718 } 5719 5720 5721 if (myequals(tokenArray[tmpK], ",") && brWithCommaLineBreak[blockIDByToken[tmpK]] 5722 && !equalsIgnoreCase(currentKeyword1, c_limit) 5723 && !equalsIgnoreCase(currentKeyword1, c_offset)) { 5724 brdz[blockIDByToken[tmpK]]++; 5725 alignStyle++; 5726 if (dbname.equals(EDbVendor.dbvoracle) && equalsIgnoreCase(brPrecedingT[blockIDByToken[tmpK]], c_decode)) { 5727 if (brdz[blockIDByToken[tmpK]] % 2 > 0) { 5728 b = myTryStrToInt(unknownMethod1(tmpK), iret); 5729 if (b) { 5730 b = myTryStrToInt(unknownMethod2(tmpK), iret); 5731 // Integer.parseInt( j( tmpK)); 5732 // Integer.parseInt( c( tmpK)); 5733 if (b) { 5734 bY = true; 5735 } else { 5736 bY = false; 5737 if (linebreakAfterComma) { 5738 linebreakAfter = 1; 5739 } 5740 if (linebreakBeforeComma) { 5741 linebreakBefore = 1; 5742 } 5743 } 5744 } 5745 } 5746 } else if (equalsIgnoreCase(brPrecedingT[blockIDByToken[tmpK]], c_in)) { // comma in IN list 5747 if (alignStyle >= valuesPerLineForINLists) { 5748 b = myTryStrToInt(unknownMethod1(tmpK), iret); 5749 if (b) { 5750 b = myTryStrToInt(unknownMethod2(tmpK), iret); 5751 // Integer.parseInt( j( tmpK)); 5752 // Integer.parseInt( c( tmpK)); 5753 if (b) { 5754 bY = true; 5755 } else { 5756 bY = false; 5757 if (linebreakAfterComma) { 5758 linebreakAfter = 1; 5759 } 5760 if (linebreakBeforeComma) { 5761 linebreakBefore = 1; 5762 } 5763 } 5764 } 5765 } 5766 } else if (alignStyle >= numberOfIdentifiersPerLine) { 5767 if (linebreakAfterComma) { 5768 linebreakAfter = 1; 5769 } 5770 if (linebreakBeforeComma) { 5771 linebreakBefore = 1; 5772 } 5773 bY = false; 5774 if (!IsInGROUPBY[tmpK] && !IsInORDERBY[tmpK]) { 5775 b = myTryStrToInt(unknownMethod1(tmpK), iret); 5776 if (b) { 5777 b = myTryStrToInt(unknownMethod2(tmpK), iret); 5778 // Integer.parseInt( j( tmpK)); 5779 // Integer.parseInt( c( tmpK)); 5780 if (b) { 5781 bY = true; 5782 linebreakAfter = 0; 5783 linebreakBefore = 0; 5784 } 5785 } 5786 } 5787 } 5788 } 5789 if (myequals(tokenArray[tmpK], ";")) { 5790 linebreakBefore = 0; 5791 linebreakAfter = 2; 5792 } 5793 5794 if (dbname.equals(EDbVendor.dbvoracle)) { 5795 if ((tokenArray[tmpK].equalsIgnoreCase(c_rollup) 5796 || tokenArray[tmpK].equalsIgnoreCase(c_cube)) 5797 && prevToken_nonComment_noEmpty(tmpK).equalsIgnoreCase(c_with)) { 5798 setKeyword1(); 5799 } 5800 if ((tokenArray[tmpK].equalsIgnoreCase(c_rollup) 5801 || tokenArray[tmpK].equalsIgnoreCase(c_cube)) 5802 && prevToken_nonComment_noEmpty(tmpK).equalsIgnoreCase(c_by)) { 5803 setKeyword1(); 5804 } 5805 if (tokenArray[tmpK].equalsIgnoreCase(c_all) 5806 && prevToken_nonComment_noEmpty(tmpK).equalsIgnoreCase(c_insert)) { 5807 setKeyword1(); 5808 linebreakBefore = 0; 5809 linebreakAfter = 1; 5810 } 5811 if (tokenArray[tmpK].equalsIgnoreCase(c_FIRST) 5812 && prevToken_nonComment_noEmpty(tmpK).equalsIgnoreCase(c_insert)) { 5813 setKeyword1(); 5814 linebreakBefore = 0; 5815 linebreakAfter = 1; 5816 } 5817 if (tokenArray[tmpK].equalsIgnoreCase(c_start_with)) { 5818 setKeyword1(); 5819 linebreakBefore = 1; 5820 } 5821 if (tokenArray[tmpK].equalsIgnoreCase(c_connect_by)) { 5822 setKeyword1(); 5823 linebreakBefore = 1; 5824 } 5825 if (tokenArray[tmpK].startsWith("&")) { 5826 linebreakBefore = 1; 5827 } 5828 } 5829 5830 if (dbname.equals(EDbVendor.dbvdb2) 5831 && tokenArray[tmpK].equalsIgnoreCase(c_concat)) { 5832 setKeyword1(); 5833 if (linebreakAfterConcatenations) { 5834 linebreakAfter = 1; 5835 } 5836 if (linebreakBeforeConcatenations) { 5837 linebreakBefore = 1; 5838 } 5839 } 5840 5841 if (dbname.equals(EDbVendor.dbvaccess)) { 5842 if (tokenArray[tmpK].equalsIgnoreCase(c_iif)) { 5843 setKeyword1(); 5844 linebreakBefore = 1; 5845 } 5846 if (tokenArray[tmpK].equalsIgnoreCase(c_char_left_paren) 5847 && prev_no_left_bracket_token.equalsIgnoreCase(c_iif)) { 5848 brSurroundsCondition[blockIDByToken[tmpK]] = true; 5849 brWithCommaLineBreak[blockIDByToken[tmpK]] = false; 5850 linebreakBefore = 1; 5851 linebreakAfter = 0; 5852 increaseAfterToken = 1; 5853 } 5854 } 5855 5856 if (dbname.equals(EDbVendor.dbvmssql) 5857 && tokenArray[tmpK].equalsIgnoreCase(c_select) 5858 && matchByPattern2(regex_select_top_with, true, tmpK, 8, c_numberOfSpace_1)) { 5859 linebreakAfter = 1; 5860 setFalseCanGetLineBreakAfter(); 5861 } 5862 5863 } 5864 5865 if (!IsInaSQL[tmpK]) { 5866 5867 if (dbname.equals(EDbVendor.dbvgeneric) || dbname.equals(EDbVendor.dbvoracle) 5868 || dbname.equals(EDbVendor.dbvsybase) || dbname.equals(EDbVendor.dbvinformix)) { 5869 if (equalsIgnoreCase(tokenArray[tmpK], c_char_left_paren)) { 5870 if (equalsIgnoreCase(prev_no_left_bracket_token, c_object) 5871 || equalsIgnoreCase(prev_no_left_bracket_token, c_record)) { 5872 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 5873 linebreakAfter = 1; 5874 linebreakBefore = 1; 5875 increaseAfterToken = 1; 5876 } 5877 if (!includeStr(c_predefined_sep + prevToken_nonEmpty(tmpK) + c_predefined_sep, datatypeStr) 5878 && (equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], c_procedure_header) 5879 || equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], c_function_header) 5880 || equalsIgnoreCase(BelongsToSPKeyword[getLastNoBracketnoCommentPos(tmpK)], c_package_header))) { 5881 // parameters 5882 brSurroundsParams[blockIDByToken[tmpK]] = true; 5883 brWithCommaLineBreak[blockIDByToken[tmpK]] = true; 5884 brSetPrimaryIndentToCursorPosition[blockIDByToken[tmpK]] = true; 5885 } 5886 } 5887 if (equalsIgnoreCase(tokenArray[tmpK], "-") && (tNbrOfPrecedingLinebreak[tmpK + 1] > 0)) { 5888 linebreakAfter = 1; 5889 } 5890 if (!IsInNonFormatZone[tmpK]) { 5891 if ((includeStr(c_predefined_sep + tokenArray[tmpK] + c_predefined_sep, sqlplusStr) || tokenArray[tmpK].startsWith("@")) 5892 && !equalsIgnoreCase(tokenArray[tmpK - 1], c_set) 5893 && (tNbrOfPrecedingLinebreak[tmpK] > 0)) { 5894 setSPKeyword(tokenArray[tmpK]); 5895 linebreakBefore = 1; 5896 } 5897 if ((myequals(tokenArray[tmpK], "/") || equalsIgnoreCase(tokenArray[tmpK], c_run)) 5898 && (tNbrOfPrecedingLinebreak[tmpK] > 0) 5899 && ((tNbrOfPrecedingLinebreak[tmpK + 1] > 0) || (tmpK == sqlTokenLen))) { 5900 setSPKeyword(tokenArray[tmpK]); 5901 linebreakBefore = 1; 5902 linebreakAfter = 1; 5903 reducedLevel = 1; 5904 } 5905 } 5906 5907 5908 if (equalsIgnoreCase(tokenArray[tmpK], c_create)) { 5909 setSPKeyword(tokenArray[tmpK]); 5910 if (matchByPattern2(regex_create_or_replace_procedure, true, tmpK, 4, c_numberOfSpace_1)) { 5911 setSPKeyword(c_procedure_header); 5912 linebreakAfter = 1; 5913 increaseAfterToken = 1; 5914 linebreakBefore = 1; 5915 } 5916 if (matchByPattern2(regex_create_or_replace_synonym, true, tmpK, 4, c_numberOfSpace_1)) { 5917 setSPKeyword(c_create_synonym); 5918 linebreakBefore = 1; 5919 } 5920 if (matchByPattern2(regex_create_or_replace_package, true, tmpK, 4, c_numberOfSpace_1)) { 5921 setSPKeyword(c_package_header); 5922 linebreakAfter = 1; 5923 increaseAfterToken = 1; 5924 linebreakBefore = 1; 5925 } 5926 if (matchByPattern2(regex_create_or_replace_function, true, tmpK, 4, c_numberOfSpace_1)) { 5927 setSPKeyword(c_function_header); 5928 linebreakAfter = 1; 5929 increaseAfterToken = 1; 5930 linebreakBefore = 1; 5931 } 5932 } 5933 if (equalsIgnoreCase(tokenArray[tmpK], c_function)) { 5934 setSPKeyword(c_function_header); 5935 if (reduceLevelRelatedB3) { 5936 reducedLevel = 1; 5937 reduceLevelRelatedB1 = false; 5938 } 5939 reduceLevelRelatedB3 = true; 5940 increaseAfterToken = 1; 5941 if (!equalsIgnoreCase(prevToken1, c_member) && !equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5942 linebreakBefore = 1; 5943 } 5944 if (reduceLevelRelatedB1) { 5945 reducedLevel = 1; 5946 reduceLevelRelatedB1 = false; 5947 } 5948 } 5949 5950 5951 if (myequals(tokenArray[tmpK], ",") && brWithCommaLineBreak[blockIDByToken[tmpK]]) { 5952 if (linebreakAfterComma) { 5953 linebreakAfter = 1; 5954 } 5955 if (linebreakBeforeComma) { 5956 linebreakBefore = 1; 5957 } 5958 } 5959 5960 if (equalsIgnoreCase(tokenArray[tmpK], "||")) { 5961 if (linebreakAfterConcatenations) { 5962 linebreakAfter = 1; 5963 } 5964 if (linebreakBeforeConcatenations) { 5965 linebreakBefore = 1; 5966 } 5967 } 5968 5969 if (equalsIgnoreCase(tokenArray[tmpK], c_procedure)) { 5970 setSPKeyword(c_procedure_header); 5971 increaseAfterToken = 1; 5972 reducedLevel = 1; 5973 if (!equalsIgnoreCase(prevToken1, c_member) && !equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5974 linebreakBefore = 1; 5975 } 5976 if (reduceLevelRelatedB1) { 5977 reducedLevel = 1; 5978 reduceLevelRelatedB1 = false; 5979 } 5980 } 5981 5982 if (equalsIgnoreCase(tokenArray[tmpK], c_package) || tokenArray[tmpK].toLowerCase().startsWith(c_package + c_char_dot)) { 5983 setSPKeyword(c_package_header); 5984 increaseAfterToken = 1; 5985 reducedLevel = 1; 5986 if (!equalsIgnoreCase(prevToken1, c_member) && !equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5987 linebreakBefore = 1; 5988 } 5989 if (reduceLevelRelatedB1) { 5990 reducedLevel = 1; 5991 reduceLevelRelatedB1 = false; 5992 } 5993 } 5994 5995 5996 if (equalsIgnoreCase(tokenArray[tmpK], c_if)) { 5997 setSPKeyword(tokenArray[tmpK]); 5998 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 5999 increaseAfterToken = 1; 6000 linebreakBefore = 1; 6001 } 6002 } 6003 if (equalsIgnoreCase(tokenArray[tmpK], c_type)) { 6004 setSPKeyword(tokenArray[tmpK]); 6005 reducedLevel = 1; 6006 } 6007 if (equalsIgnoreCase(tokenArray[tmpK], c_loop)) { 6008 setSPKeyword(tokenArray[tmpK]); 6009 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 6010 increaseAfterToken = 1; 6011 linebreakAfter = 1; 6012 linebreakBefore = 1; 6013 } 6014 } 6015 if (equalsIgnoreCase(tokenArray[tmpK], c_declare)) { 6016 setSPKeyword(tokenArray[tmpK]); 6017 reduceLevelRelatedB2 = true; 6018 linebreakBefore = 1; 6019 increaseAfterToken = 1; 6020 linebreakAfter = 1; 6021 } 6022 if (equalsIgnoreCase(tokenArray[tmpK], c_return)) { 6023 setSPKeyword(tokenArray[tmpK]); 6024 linebreakBefore = 1; 6025 } 6026 if (equalsIgnoreCase(tokenArray[tmpK], c_begin)) { 6027 setSPKeyword(tokenArray[tmpK]); 6028 increaseAfterToken = 1; 6029 if (reduceLevelRelatedB1 || reduceLevelRelatedB2) { 6030 reduceLevelRelatedB1 = false; 6031 reduceLevelRelatedB2 = false; 6032 reducedLevel = 1; 6033 } 6034 linebreakAfter = 1; 6035 linebreakBefore = 1; 6036 } 6037 6038 if ((equalsIgnoreCase(tokenArray[tmpK], c_is) || equalsIgnoreCase(tokenArray[tmpK], c_as)) 6039 && !equalsIgnoreCase(brPrecedingT[blockIDByToken[tmpK]], c_cast) 6040 && !includeStr(c_predefined_sep + nextSolidToken(tmpK) + c_predefined_sep, datatypeStr) 6041 && (equalsIgnoreCase(BelongsToSPKeyword[tmpK], c_procedure_header) 6042 || equalsIgnoreCase(BelongsToSPKeyword[tmpK], c_function_header) 6043 || equalsIgnoreCase(BelongsToSPKeyword[tmpK], c_package_header))) { 6044 setSPKeyword(tokenArray[tmpK]); 6045 reduceLevelRelatedB1 = true; 6046 increaseAfterToken = 1; 6047 reducedLevel = 1; 6048 linebreakAfter = 1; 6049 linebreakBefore = 1; 6050 } 6051 if (equalsIgnoreCase(tokenArray[tmpK], c_cursor)) { 6052 setSPKeyword(tokenArray[tmpK]); 6053 if (matchByPattern2(regex_cursor_is, true, tmpK, 2, c_numberOfSpace_1)) { 6054 linebreakAfter = 1; 6055 } 6056 reduceAfterRelatedB1 = true; 6057 increaseAfterToken = 1; 6058 linebreakBefore = 1; 6059 } 6060 if (equalsIgnoreCase(tokenArray[tmpK], c_exception) 6061 && !myequals(nextSolidToken(tmpK), c_char_semicolon)) { 6062 setSPKeyword(tokenArray[tmpK]); 6063 increaseAfterToken = 1; 6064 reducedLevel = 1; 6065 linebreakAfter = 1; 6066 linebreakBefore = 1; 6067 } 6068 if (equalsIgnoreCase(tokenArray[tmpK], c_end)) { 6069 setSPKeyword(tokenArray[tmpK]); 6070 reducedLevel = 1; 6071 linebreakBefore = 1; 6072 } 6073 if (equalsIgnoreCase(tokenArray[tmpK], c_case)) { 6074 setSPKeyword(tokenArray[tmpK]); 6075 if (!equalsIgnoreCase(prevToken_nonComment_noEmpty(tmpK), c_end)) { 6076 increaseAfterToken = 1; 6077 linebreakBefore = 1; 6078 } 6079 } 6080 6081 if (equalsIgnoreCase(tokenArray[tmpK], c_when)) { 6082 setSPKeyword(tokenArray[tmpK]); 6083 linebreakBefore = 1; 6084 increaseAfterToken = 1; 6085 reducedLevel = 1; 6086 } 6087 if (equalsIgnoreCase(tokenArray[tmpK], c_for)) { 6088 setSPKeyword(tokenArray[tmpK]); 6089 } 6090 if (equalsIgnoreCase(tokenArray[tmpK], c_then)) { 6091 setSPKeyword(tokenArray[tmpK]); 6092 linebreakAfter = 1; 6093 } 6094 if (equalsIgnoreCase(tokenArray[tmpK], c_in)) { 6095 setSPKeyword(tokenArray[tmpK]); 6096 } 6097 if (equalsIgnoreCase(tokenArray[tmpK], c_else)) { 6098 setSPKeyword(tokenArray[tmpK]); 6099 linebreakBefore = 1; 6100 linebreakAfter = 1; 6101 increaseAfterToken = 1; 6102 reducedLevel = 1; 6103 } 6104 if (equalsIgnoreCase(tokenArray[tmpK], c_elseif) || equalsIgnoreCase(tokenArray[tmpK], c_elsif)) { 6105 setSPKeyword(tokenArray[tmpK]); 6106 linebreakBefore = 1; 6107 linebreakAfter = 0; 6108 increaseAfterToken = 1; 6109 reducedLevel = 1; 6110 } 6111 6112 if (equalsIgnoreCase(tokenArray[tmpK], c_or)) { 6113 if (SPLinebreakAfterANDORofCondition) { 6114 linebreakAfter = 1; 6115 } 6116 if (SPLinebreakBeforeANDORofCondition) { 6117 linebreakBefore = 1; 6118 } 6119 } 6120 if (equalsIgnoreCase(tokenArray[tmpK], c_and)) { 6121 if (SPLinebreakAfterANDORofCondition) { 6122 linebreakAfter = 1; 6123 } 6124 if (SPLinebreakBeforeANDORofCondition) { 6125 linebreakBefore = 1; 6126 } 6127 } 6128 if (myequals(tokenArray[tmpK], c_char_semicolon)) { 6129 setSPKeyword(tokenArray[tmpK]); 6130 BelongsToSPKeyword[tmpK] = ""; 6131 linebreakAfter = 1; 6132 } 6133 6134 } 6135 6136 if (dbname.equals(EDbVendor.dbvdb2)) { 6137 processDB2Linebreak(); 6138 } 6139 if (dbname.equals(EDbVendor.dbvmysql)) { 6140 processMySQLLinebreak(); 6141 } 6142 if (dbname.equals(EDbVendor.dbvmssql)) { 6143 processSQLServerLinebreak(); 6144 if (IsStartOfaSQL[skipToNextNonEmptyToken(tmpK)] && sqlserverb1) { 6145 sqlserverb1 = false; 6146 reduceAfterToken = 1; 6147 } 6148 } 6149 6150 } 6151 } 6152 6153 flag = true; 6154 if (eb1 > 0) { 6155 eb1--; 6156 if (!ec1) { 6157 flag = false; 6158 linebreakAfter = linebreakBefore; 6159 linebreakBefore = 0; 6160 if (tNbrKeyword1[posOfPrevToken_nonEmpty(tmpK)]) { 6161 tNbrKeyword1[tmpK] = true; 6162 } 6163 if (tNbrdl[posOfPrevToken_nonEmpty(tmpK)]) { 6164 tNbrdl[tmpK] = true; 6165 } 6166 } 6167 ec1 = false; 6168 } 6169 6170 tNbrProcessThisToken[tmpK] = true; 6171 6172 if (IsInComment[tmpK] && deleteComments) { 6173 tNbrProcessThisToken[tmpK] = false; 6174 } 6175 6176 if (tNbrProcessThisToken[tmpK]) { 6177 if (flag) { 6178 if (!IsInNonFormatZone[tmpK]) { 6179 if (myequals(tokenArray[tmpK], c_char_left_paren)) { 6180 if ((dbname == EDbVendor.dbvoracle) 6181 && equalsIgnoreCase(brPrecedingT[blockIDByToken[tmpK]], c_decode)) { 6182 increaseAfterToken = 1; 6183 } 6184 if (brAfterSQLMasterKeyword[blockIDByToken[tmpK]] 6185 && !isSelectToken(nextToken_nocomment_noempty_noleftbracket(tmpK))) { 6186 increaseAfterToken = 1; 6187 } 6188 if (brAfterInsertValuesKeyword[blockIDByToken[tmpK]] 6189 && !isSelectToken(nextToken_nocomment_noempty_noleftbracket(tmpK)) 6190 && indentColumnValueOfInsert) { 6191 increaseAfterToken = 1; 6192 } 6193 if (brSurroundsSQL[blockIDByToken[tmpK]] && indentSubquery) { 6194 increaseAfterToken = 1; 6195 } 6196 if (IsInaSQL[tmpK] && brSurroundsCondition[blockIDByToken[tmpK]] 6197 && indentConditionInParenthesis) { 6198 increaseAfterToken = 1; 6199 } 6200 if (!IsInaSQL[tmpK] && brSurroundsCondition[blockIDByToken[tmpK]] 6201 && SPIndentConditionInBracket) { 6202 increaseAfterToken = 1; 6203 } 6204 if (!IsInaSQL[tmpK] && brSurroundsParams[blockIDByToken[tmpK]] 6205 && SPIndentParameterInBracket) { 6206 increaseAfterToken = 1; 6207 } 6208 if (brSetPrimaryIndentToCursorPosition[blockIDByToken[tmpK]] 6209 && !brSurroundsParams[blockIDByToken[tmpK]]) { 6210 increaseAfterToken = 0; 6211 } 6212 if (brSurroundsCase[blockIDByToken[tmpK]] && indentCaseInBracket) { 6213 increaseAfterToken = 1; 6214 } 6215 } 6216 if (IsInaSQL[tmpK] 6217 && (equalsIgnoreCase(tokenArray[tmpK], c_and) 6218 || equalsIgnoreCase(tokenArray[tmpK], c_or)) 6219 && !indentANDOR && linebreakBeforeAndOr) { 6220 reducedLevel = 1; 6221 increaseAfterToken = 1; 6222 } 6223 if (startTokenOfMasterSQL[tmpK]) { 6224 if (indentMasterKeyword) { 6225 increaseAfterToken = 2; 6226 } else { 6227 increaseAfterToken = 1; 6228 } 6229 } 6230 } 6231 6232 if (IsStartJOIN[tmpK] && !indentJoinStatement) { 6233 reducedLevel = 1; 6234 } 6235 if (IsEndJOIN[tmpK]) { 6236 if (indentJoinStatement && (!myequals(tokenArray[tmpK], c_char_right_paren) 6237 || !brSurroundsSQL[blockIDByToken[tmpK]])) { 6238 reduceAfterToken = 1; 6239 } 6240 if (indentOnStatement && IsEndJOIN_ON[tmpK]) { 6241 reduceAfterToken++; 6242 } 6243 } 6244 6245 if (IsEndOfaSQL[tmpK]) { 6246 if (myequals(tokenArray[tmpK], c_char_right_paren) && brSurroundsSQL[blockIDByToken[tmpK]]) { 6247 reduceAfterToken = 1; 6248 if ((IsEndOfCompleteSQL[tmpK] && blockIsSQL[blockIDByToken[tmpK]]) 6249 || (!IsEndOfCompleteSQL[tmpK] 6250 && !startTokenOfMasterSQL[posOfNextToken_nonComment_nonEmpty(tmpK)])) { 6251 reduceAfterToken = 0; 6252 } 6253 } else { 6254 reduceAfterToken = 1; 6255 if (indentMasterKeyword) { 6256 reduceAfterToken++; 6257 } 6258 if (IsEndJOIN[tmpK] && indentJoinStatement) { 6259 reduceAfterToken++; 6260 } 6261 } 6262 if (reduceAfterRelatedB1 && !IsStartOfaSQL[skipToNextNonEmptyToken(tmpK)]) { 6263 reduceAfterToken++; 6264 reduceAfterRelatedB1 = false; 6265 } 6266 } 6267 6268 processLinebreak(); 6269 6270 if (formatSQLOn1Line && IsInaSQL[tmpK]) { 6271 linebreakAfter = 0; 6272 linebreakBefore = 0; 6273 } 6274 if (!formatSQLOn1Line) { 6275 j1 = posOfPrevToken_nonEmpty(tmpK); 6276 if (isEndLineComment[j1] && linebreakBefore == 0) { 6277 linebreakBefore = 1; 6278 } 6279 if (isEndBlockComment[j1] && tNbrOfPrecedingLinebreak[tmpK] > 0) { 6280 if (keepEmptyLine) { 6281 linebreakBefore = tNbrOfPrecedingLinebreak[tmpK]; 6282 } else { 6283 linebreakBefore = 1; 6284 } 6285 } 6286 if (isEndBlockComment[j1] && linebreakBeforeBlockComment && linebreakBefore == 0) { 6287 linebreakBefore = 1; 6288 } 6289 } 6290 if (myequals(tokenArray[tmpK], c_char_left_paren) && !IsInNonFormatZone[tmpK]) { 6291 brPrimaryIndentBeforBr[blockIDByToken[tmpK]] = indentLength; 6292 } 6293 indentLength += increasedLevel * currentIndentSize; 6294 indentLength -= reducedLevel * currentIndentSize; 6295 if (indentLength < 0) { 6296 indentLength = 0; 6297 } 6298 if (!IsEndOfaSQL[tmpK] && myequals(tokenArray[tmpK], c_char_right_paren) 6299 && indentLength < SQLPrimaryIndent[SQLIDByToken[tmpK]]) { 6300 indentLength = SQLPrimaryIndent[SQLIDByToken[tmpK]]; 6301 } 6302 if (!IsInNonFormatZone[tmpK]) { 6303 if (startTokenOfMasterSQL[tmpK] && SQLPrimaryIndent[SQLIDByToken[tmpK]] == 0) { 6304 SQLPrimaryIndent[SQLIDByToken[tmpK]] = indentLength; 6305 } 6306 if (myequals(tokenArray[tmpK], c_char_left_paren)) { 6307 if (brSetPrimaryIndentToCursorPosition[blockIDByToken[tmpK]]) { 6308 indentLength = (short) (ColumnPosOfCurrentToken + tokenArray[tmpK].length() 6309 + tNbrOfPrecedingBlanks[tmpK]); 6310 } 6311 brPrimaryIndent[blockIDByToken[tmpK]] = indentLength; 6312 } 6313 if (startTokenOfMasterSQL[tmpK] && SQLbL[SQLIDByToken[tmpK]]) { 6314 brPrimaryIndent[blockIDByToken[tmpK]] = indentLength; 6315 } 6316 if (equalsIgnoreCase(tokenArray[tmpK], c_char_right_paren)) { 6317 indentLength = brPrimaryIndent[blockIDByToken[tmpK]]; 6318 } 6319 } 6320 doIndentRelated(); 6321 doCalculatePrecedingSpace1(); 6322 doCalculateNbrOfPrecedingBlanks1(); 6323 unknownMethod3(); 6324 tNbrOfPrecedingLinebreakOutputSQL[tmpK] = linebreakBefore; 6325 if (keepEmptyLine && linebreakBefore > 0 && tNbrOfPrecedingLinebreak[tmpK] > 1 6326 && tNbrOfPrecedingLinebreak[tmpK] > tNbrOfPrecedingLinebreakOutputSQL[tmpK]) { 6327 tNbrOfPrecedingLinebreakOutputSQL[tmpK] = tNbrOfPrecedingLinebreak[tmpK]; 6328 } 6329 if (tNbrOfPrecedingLinebreakOutputSQL[tmpK] > 0) { 6330 checkOutputSQLBuffer(); 6331 } 6332 doAlign(); 6333 } 6334 6335 if (!IsInFrozenZone[tmpK]) { 6336 doModifyCase(); 6337 doColorSQL(); 6338 } 6339 doAddProcessedTokenToStringBuilder(); 6340 } 6341 6342 doApplyDebugInstruction(); 6343 prepareForNextToken(); 6344 6345 tmpK++; 6346 6347 } 6348 } 6349 6350 public String prevNonCommentToken(int i1) { 6351 String s1 = ""; 6352 boolean flag = false; 6353 boolean flag1 = false; 6354 int posOfSearchedToken = i1; 6355 while (true) { 6356 if (posOfSearchedToken <= 1 || flag || flag1) { 6357 break; 6358 } 6359 posOfSearchedToken--; 6360 if (!IsInComment[posOfSearchedToken]) { 6361 if (!(tokenArray[posOfSearchedToken].length() == 0)) { 6362 s1 = tokenArray[posOfSearchedToken]; 6363 flag = true; 6364 } 6365 } else { 6366 flag1 = true; 6367 } 6368 } 6369 return s1; 6370 } 6371 6372 public void alignToken(int pTokenPos, int pAlignType, String pDirection, String pIgnoreBracketLevel) { 6373 int i, s1int, s2int, i2, l1, k1, j2, k2; 6374 int word0; 6375 6376 if (numsOfTokenToAlign[pAlignType] == 0) { // first line 6377 bracketLevelOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = bracketsInBlock[blockIDByToken[pTokenPos]]; 6378 tokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = tokenArray[pTokenPos]; 6379 posOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = pTokenPos; 6380 lineOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = lineNumber; 6381 numsOfTokenAbleToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = 0; 6382 if (equalsIgnoreCase(pDirection, align_right)) 6383 columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = (ColumnPosOfCurrentToken + tNbrOfPrecedingBlanks[tmpK] + tokenArray[pTokenPos].length()) - 1; 6384 else 6385 columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = (ColumnPosOfCurrentToken + tNbrOfPrecedingBlanks[tmpK] + tokenArray[pTokenPos].length()) - tokenArray[pTokenPos].length(); 6386 numsOfTokenToAlign[pAlignType]++; 6387 } else { 6388 if (lineOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - 1] == lineNumber) 6389 return; 6390 bracketLevelOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = bracketsInBlock[blockIDByToken[pTokenPos]]; 6391 tokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = tokenArray[pTokenPos]; 6392 posOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = pTokenPos; 6393 lineOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = lineNumber; 6394 if (equalsIgnoreCase(pDirection, align_right)) 6395 columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = (ColumnPosOfCurrentToken + tNbrOfPrecedingBlanks[tmpK] + tokenArray[pTokenPos].length()) - 1; 6396 else 6397 columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = (ColumnPosOfCurrentToken + tNbrOfPrecedingBlanks[tmpK] + tokenArray[pTokenPos].length()) - tokenArray[pTokenPos].length(); 6398 if ((lineOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - 1] < lineNumber - 1) || myequals(pIgnoreBracketLevel, boolean_no) && (bracketLevelOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - 1] != bracketsInBlock[blockIDByToken[pTokenPos]])) { 6399 numsOfTokenAbleToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = 0; 6400 } else { 6401 numsOfTokenAbleToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] = (short)(numsOfTokenAbleToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - 1] + 1); 6402 if (columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - 1] > columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]]) { 6403 pTokenPos = columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - 1] - columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]]; 6404 if (pTokenPos < 0) 6405 pTokenPos = 0; 6406 tNbrOfPrecedingBlanks[posOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]]] += pTokenPos; 6407 columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] += pTokenPos; 6408 } 6409 if (columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - 1] < columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]]) { 6410 for (pTokenPos = 1; pTokenPos <= numsOfTokenAbleToAlign[pAlignType][numsOfTokenToAlign[pAlignType]]; pTokenPos++) { 6411 s1int = columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType]] - columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - pTokenPos]; 6412 s2int = maxLineWidth - dR[lineOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - pTokenPos]]; 6413 if (s2int <= 0) 6414 continue; 6415 s1int = Math.min(s1int, s2int); 6416 if (s1int < 0) 6417 s1int = 0; 6418 tNbrOfPrecedingBlanks[posOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - pTokenPos]] += s1int; 6419 i2 = s1int; 6420 l1 = lineOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - pTokenPos]; 6421 k1 = posOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - pTokenPos]; 6422 s2int = columnPosOfTokenToAlign[pAlignType][numsOfTokenToAlign[pAlignType] - pTokenPos]; 6423 j2 = 1; 6424 while (true) { 6425 if (j2 > MAX_ALIGN_TOKENS) 6426 break; 6427 for (k2 = 0; k2 <= numsOfTokenToAlign[j2]; k2++) { 6428 if (posOfTokenToAlign[j2][k2] >= k1 && lineOfTokenToAlign[j2][k2] == l1 && columnPosOfTokenToAlign[j2][k2] >= s2int) { 6429 columnPosOfTokenToAlign[j2][k2] += i2; 6430 dR[l1] += i2; 6431 } 6432 } 6433 j2++; 6434 } 6435 } 6436 } 6437 } 6438 numsOfTokenToAlign[pAlignType]++; 6439 if (numsOfTokenToAlign[pAlignType] >= bz) { 6440 bz += 1000; 6441 for (word0 = 1; word0 <= MAX_ALIGN_TOKENS; word0++) { 6442 tokenToAlign = new String[word0][bz]; 6443 posOfTokenToAlign = new int[word0][bz]; 6444 lineOfTokenToAlign = new int[word0][bz]; 6445 columnPosOfTokenToAlign = new int[word0][bz]; 6446 numsOfTokenAbleToAlign = new short[word0][bz]; 6447 bracketLevelOfTokenToAlign = new short[word0][bz]; 6448 6449 } 6450 numsOfTokenToAlign = new int[bz]; 6451 } 6452 } 6453 initNextTokenOfThisAlignType(pAlignType, numsOfTokenToAlign[pAlignType]); 6454 } 6455 6456 public void initNextTokenOfThisAlignType(int i1, int j1) { 6457 bracketLevelOfTokenToAlign[i1][j1] = 0; 6458 tokenToAlign[i1][j1] = " "; 6459 posOfTokenToAlign[i1][j1] = 0; 6460 numsOfTokenAbleToAlign[i1][j1] = 0; 6461 lineOfTokenToAlign[i1][j1] = 0; 6462 columnPosOfTokenToAlign[i1][j1] = 0; 6463 } 6464 6465 public void addFunctions(ArrayList<String> functionList, String[] functionArray) { 6466 for (int i = 0; i < functionArray.length; i++) { 6467 functionList.add(functionArray[i]); 6468 } 6469 } 6470 6471 public boolean matchByPattern(String pattern, boolean caseInsensitive, int startPos, int len, String numberOfSpace) { 6472 boolean result = false; 6473 Pattern r = null; 6474 Matcher matcher = null; 6475 6476 try { 6477 r = Pattern.compile(pattern, caseInsensitive ? Pattern.CASE_INSENSITIVE : 0); 6478 matcher = r.matcher(tokenArray[startPos] + concatTokens(startPos, len, numberOfSpace)); 6479 result = matcher.find(); 6480 } finally { 6481 if (matcher != null) { 6482 matcher.reset(); 6483 } 6484 } 6485 6486 return result; 6487 } 6488 6489 public boolean matchByPattern2(String pattern, boolean caseInsensitive, int startPos, int len, String numberOfSpace) { 6490 boolean result = false; 6491 Pattern r = null; 6492 Matcher matcher = null; 6493 6494 try { 6495 r = Pattern.compile(pattern, caseInsensitive ? Pattern.CASE_INSENSITIVE : 0); 6496 matcher = r.matcher(tokenArray[startPos] + concatTokens(startPos, len, numberOfSpace)); 6497 6498 result = matcher.find(); 6499 if (result) { 6500 String s = matcher.group(0); 6501 String[] tokens = s.split(" "); 6502 eb1 = tokens.length; 6503 ec1 = true; 6504 } 6505 } finally { 6506 if (matcher != null) { 6507 matcher.reset(); 6508 } 6509 } 6510 6511 return result; 6512 } 6513 6514 public boolean isValidIdentifier(String str, boolean caseInsensitive) { 6515 boolean result = false; 6516 Pattern r = null; 6517 Matcher matcher = null; 6518 6519 try { 6520 r = Pattern.compile(PatternBn, caseInsensitive ? Pattern.CASE_INSENSITIVE : 0); 6521 matcher = r.matcher(str); 6522 result = matcher.matches(); 6523 } finally { 6524 if (matcher != null) { 6525 matcher.reset(); 6526 } 6527 } 6528 6529 return result; 6530 } 6531 6532 public void outputFormattedSQL() { 6533 int currentOutputLine = 0; 6534 int j1 = 0, j2, k1, k2, k6; 6535 String s1, s2, s7, s8; 6536 String s3, s6, s4; 6537 long l1, i3; 6538 6539 currentOutputLine = 0; 6540 j1 = 0; 6541 6542 bO1 = ""; 6543 bP1 = ""; 6544 if (deleteComments && inComment1) 6545 bN += lineSeparator; 6546 if (isRemoveUnnecessaryBracket && findUnnecessaryBracket) 6547 bN += lineSeparator; 6548 if (replaceHostVariable && (hostVariableRelatedCount > 0)) 6549 bN += lineSeparator; 6550 l1 = 0; 6551 neverExpired = true; 6552 if (neverExpired) { 6553 if (colorRelatedB1) { 6554 colorByte = 2; 6555 addToFormattedSQL(bP1); 6556 } 6557 colorByte = 4; 6558 addToFormattedSQL(output_start_line); 6559 s6 = ""; 6560 for (j2 = 1; j2 <= additionalIndent; j2++) 6561 s6 += " "; 6562 6563 tmpK = 1; 6564 while (tmpK <= sqlTokenLen) { 6565 if (tokenArray[tmpK].length() == 0) 6566 tmpK = skipToNonEmptyToken(tmpK + 1); 6567 if (!IsInFrozenZone[tmpK]) { 6568 if (!tNbrProcessThisToken[tmpK]) { 6569 tmpK++; 6570 continue; 6571 } 6572 for (k2 = 1; k2 <= tNbrOfPrecedingLinebreakOutputSQL[tmpK]; k2++) { 6573 j1 = 0; 6574 currentOutputLine++; 6575 if (showLineNumber) { 6576 s4 = Integer.toString(currentOutputLine); 6577 if (currentOutputLine == 1) { 6578 colorByte = 4; 6579 addToFormattedSQL(output_start_of_each_line + s4 + " "); 6580 } 6581 if (currentOutputLine > 1) { 6582 colorByte = 4; 6583 addToFormattedSQL(output_end_of_each_line + output_start_of_each_line + s4 + " "); 6584 } 6585 } else { 6586 if (currentOutputLine == 1) { 6587 colorByte = 4; 6588 addToFormattedSQL(output_start_of_each_line); 6589 } 6590 if (currentOutputLine > 1) { 6591 colorByte = 4; 6592 addToFormattedSQL(output_end_of_each_line + output_start_of_each_line); 6593 } 6594 } 6595 s2 = s6; 6596 k1 = 0; 6597 assert indentOfEachlineWithPaddingSpace.length > currentOutputLine; 6598 while (k1 < indentOfEachlineWithPaddingSpace[currentOutputLine]) { 6599 if (showIndentionLevel && (k1 % genericIndentSize == 0) 6600 && (k1 < indentOfEachline[currentOutputLine])) { 6601 s2 += "|"; 6602 k1++; 6603 continue; 6604 } 6605 if (useTab) { 6606 if ((k1 > 0) && ((k1 + 1) % genericIndentSize == 0)) 6607 s2 += "\t"; 6608 if ((indentOfEachlineWithPaddingSpace[currentOutputLine] % genericIndentSize > 0) 6609 && (indentOfEachlineWithPaddingSpace[currentOutputLine] 6610 - (k1 + 1) < indentOfEachlineWithPaddingSpace[currentOutputLine] 6611 % genericIndentSize)) 6612 s2 += " "; 6613 k1++; 6614 continue; 6615 } 6616 if (!showIndentionLevel && !useTab) { 6617 s2 += spaceArray[Math.min(NUMBER_OF_WHITESPACE, 6618 indentOfEachlineWithPaddingSpace[currentOutputLine])]; 6619 k1 = indentOfEachlineWithPaddingSpace[currentOutputLine]; 6620 } else { 6621 s2 += " "; 6622 } 6623 k1++; 6624 } 6625 colorByte = 4; 6626 addToFormattedSQL(s2); 6627 } 6628 s7 = spaceArray[Math.min(NUMBER_OF_WHITESPACE, tNbrOfPrecedingBlanks[tmpK])]; 6629 colorByte = tNbrColorRelated[tmpK]; 6630 if (showPseudoCode) { 6631 // if(++j1 <= 3) 6632 // addToFormattedSQL(s7 + tokenArray[tmpK]); 6633 // if(j1 == 3) 6634 // addToFormattedSQL(" ..."); 6635 } else { 6636 addToFormattedSQL(s7 + tokenArray[tmpK]); 6637 } 6638 tmpK++; 6639 continue; 6640 } 6641 currentOutputLine += tNbrOfPrecedingLinebreakOutputSQL[tmpK]; 6642 for (i3 = 1; i3 <= tNbrOfPrecedingLinebreak[tmpK]; i3++) 6643 addToFormattedSQL(lineSeparator); 6644 6645 colorByte = 4; 6646 s8 = spaceArray[Math.min(NUMBER_OF_WHITESPACE, tNbrOfPrecedingBlanks2[tmpK])]; 6647 addToFormattedSQL(s8 + tokenArray[tmpK]); 6648 6649 tmpK++; 6650 } 6651 6652 colorByte = 4; 6653 addToFormattedSQL(output_end_line); 6654 if (colorRelatedB1) { 6655 colorByte = 2; 6656 addToFormattedSQL(bO1); 6657 } 6658 return; 6659 } 6660 6661 try { 6662 colorByte = 4; 6663 addToFormattedSQL(inputSQLText); 6664 return; 6665 } catch (Exception e) { 6666 return; 6667 } 6668 } 6669 6670 public void addToFormattedSQL(String str) { 6671 if (!(str.length() == 0)) 6672 formattedSQL.append(str); 6673 } 6674 6675 public String getFormattedSQL() { 6676 outputFormattedSQL(); 6677 return formattedSQL.toString(); 6678 } 6679 6680 public void initFormatOptions(EDbVendor vendor, GFmtOpt option) { 6681 // general 6682 genericIndentSize = 4; 6683 useTab = false; 6684 maxLineWidth = 9999; 6685 6686 // indent 6687 indentMasterKeyword = false; 6688 indentANDOR = false; 6689 indentSubquery = true; 6690 6691 indentJoinStatement = false; 6692 indentOnStatement = false; 6693 6694 indentConditionInParenthesis = true; 6695 additionalIndent = 0; 6696 keepFirstLineIndent = false; 6697 6698 indentCaseThen = false; 6699 indentCaseElse = false; 6700 6701 SPIndentConditionInBracket = true; 6702 SPIndentParameterInBracket = false; 6703 indentColumnValueOfInsert = true; 6704 indentBlockComment = true; 6705 indentCaseInBracket = false; 6706 6707 // linebreak 6708 breakAfterMasterKeyword = true; 6709 6710 smallSQLLen = 10; 6711 breaksAroundUnionIntersect = true; 6712 6713 linebreakBeforeComma = false; 6714 linebreakAfterComma = true; 6715 6716 linebreakBeforeAndOr = true; 6717 linebreakAfterANDOR = false; 6718 6719 linebreakAfterLeftBracketOfACondition = true; 6720 6721 // join 6722 breakBeforeONkeyword = true; 6723 6724 // subquery 6725 linebreakBeforeEndParenthesisOfSubquery = false; 6726 linebreakAfterEndParenthesisOfSubquery = false; 6727 linebreakAfterLeftBracketsOfSubSelect = true; 6728 linebreakBeforeStartParenthesisOfSubquery = true; 6729 6730 // case 6731 linebreakForCase = false; 6732 linebreakBeforeCaseThen = true; 6733 linebreakBeforeCaseElse = true; 6734 linebreakBeforeCaseWhen = true; 6735 linebreakBeforeCaseANDOR = true; 6736 linebreakBeforeStartParenthesisOfCase = false; 6737 linebreakAfterStartParenthesisOfCase = true; 6738 linebreakBeforeEndParenthesisOfCase = false; 6739 linebreakAfterEndParenthesisOfCase = false; 6740 6741 linebreakBeforeConcatenations = true; 6742 linebreakAfterConcatenations = false; 6743 linebreakBeforeLineComment = false; 6744 linebreakBeforeBlockComment = true; 6745 keepEmptyLine = false; 6746 valuesPerLineForINLists = 1; 6747 6748 // condition 6749 linebreakBeforeStartParenthesisOfCondition = false; 6750 linebreakBeforeEndParenthesisOfCondition = false; 6751 linebreakAfterEndParenthesisOfCondition = false; 6752 SPLinebreakBeforeStartParenthesisofCondition = true; 6753 SPLinebreakAfterStartParenthesisofCondition = true; 6754 6755 SPLinebreakBeforeANDORofCondition = true; 6756 SPLinebreakAfterANDORofCondition = true; 6757 SPLinebreakBeforeEndParenthesisofCondition = true; 6758 SPLinebreakAfterEndParenthesisofCondition = true; 6759 SPLinebreakBeforeStartParenthesisofParameters = false; 6760 SPLinebreakAfterStartParenthesisofParameters = false; 6761 6762 // insert statement 6763 linebreakBeforeStartParenthesisOfInsert = true; 6764 linebreakAfterStartParenthesisOfInsert = true; 6765 linebreakBeforeEndParenthesisOfInsert = true; 6766 linebreakAfterEndParenthesisOfInsert = true; 6767 6768 if (linebreakBeforeComma && !linebreakAfterComma) 6769 moveComma2colsToTheLeft = true; 6770 else 6771 moveComma2colsToTheLeft = false; 6772 6773 SPLinebreakBeforeEndParenthesisofParameters = false; 6774 6775 // align 6776 alignEqualSigns = true; 6777 alignOperator = true; 6778 rightAlignMasterKeywords = false; 6779 6780 alignAliasName = true; 6781 alignLineComment = true; 6782 SPAlignDeclareVariable = true; 6783 alignConcateOP = true; 6784 alignCommaInList = true; 6785 alignAliasNameAtPredefinedPos = false; 6786 alignAliasNamePos = 65; 6787 leftAlignBlockComment = true; 6788 6789 // space 6790 removeUnnecessayWhiteSpaces = true; 6791 spaceAroundBracketOption = c_unchangedSpaceInsideBracket; 6792 spaceAroundCommaOption = c_unchangedSpaceComma; 6793 spaceAroundOperatorOption = c_unchangedEqualComma; 6794 escapeCharacter = true; 6795 showPseudoCode = false; 6796 flexibleSpaceCalculation = false; 6797 alwaysPut1SpaceAfterComma = false; 6798 6799 // keep layout 6800 enableNonFormat = false; 6801 nonFormatStartTag = "begin_no_format"; 6802 nonFormatEndTag = "end_no_format"; 6803 6804 // refactor 6805 deleteComments = false; 6806 replaceHostVariable = false; 6807 isRemoveUnnecessaryBracket = false; 6808 putHostVariableBetweenSlashStar = false; 6809 6810 // case options 6811 keywordUpper = true; 6812 onlyKeywordUpper = false; 6813 keywordLower = false; 6814 wholeUpper = false; 6815 wholeLower = false; 6816 caseCustomizedKeywords = ""; 6817 caseCustomizedVariableType = ""; 6818 6819 // misc 6820 dbname = vendor; 6821 showIndentionLevel = false; 6822 outputFormat = "SQL"; 6823 literalQuote = "'"; 6824 charEncloseSQL = "\""; 6825 colouredSQL = true; 6826 formatSQLOn1Line = false; 6827 SQLFromProgram = false; 6828 showLineNumber = false; 6829 outVariableName = "VAR"; 6830 putCommentBetweenSlashStar = false; 6831 numberOfIdentifiersPerLine = 1; 6832 6833 this.useTab = option.useTab; 6834 this.genericIndentSize = option.indentLen.shortValue(); 6835 this.maxLineWidth = option.lineWidth; 6836 switch (option.selectColumnlistComma) { 6837 case LfAfterComma: 6838 this.linebreakAfterComma = true; 6839 this.linebreakBeforeComma = false; 6840 break; 6841 case LfBeforeComma: 6842 this.linebreakAfterComma = false; 6843 this.linebreakBeforeComma = true; 6844 break; 6845 } 6846 6847 this.breakBeforeONkeyword = option.selectFromclauseJoinOnInNewline; 6848 this.deleteComments = option.removeComment; 6849 switch(option.caseKeywords) { 6850 case CoUppercase: 6851 this.keywordUpper = true; 6852 this.keywordLower = false; 6853 break; 6854 case CoLowercase: 6855 this.keywordUpper = false; 6856 this.keywordLower = true; 6857 } 6858 6859 this.linebreakBeforeCaseThen = option.caseWhenThenInSameLine; 6860 if (option.alignJoinWithFromKeyword) { 6861 this.indentJoinStatement = true; 6862 } 6863 else { 6864 this.indentJoinStatement = false; 6865 } 6866 6867 this.alignAliasName = option.alignAliasInSelectList; 6868 6869 if(option.wsPaddingOperatorArithmetic) { 6870 this.spaceAroundOperatorOption = "oneSpaceAroundEqual"; 6871 } 6872 else { 6873 this.spaceAroundOperatorOption = "noSpacesAroundEqual"; 6874 } 6875 6876 if(option.wsPaddingParenthesesInFunction 6877// || option.wsPaddingParenthesesInExpression 6878 || option.wsPaddingParenthesesOfSubQuery 6879 || option.wsPaddingParenthesesInFunctionCall 6880 || option.wsPaddingParenthesesOfTypename) { 6881 this.spaceAroundBracketOption = "oneSpaceAroundBracket"; 6882 } 6883 else { 6884 this.spaceAroundBracketOption = "noSpacesAroundBracket"; 6885 } 6886 6887 switch (option.selectKeywordsAlignOption) { 6888 case AloLeft: 6889 this.indentMasterKeyword = false; 6890 this.rightAlignMasterKeywords = false; 6891 break; 6892 case AloRight: 6893 this.indentMasterKeyword = true; 6894 this.rightAlignMasterKeywords = true; 6895 break; 6896 } 6897 6898 this.linebreakBeforeCaseThen = option.caseWhenThenInSameLine; 6899 this.breakAfterMasterKeyword = option.selectItemInNewLine; 6900 this.showLineNumber = option.linenumberEnabled; 6901 } 6902 6903 public static void main(String[] args) { 6904 SQLion sqLion = new SQLion(EDbVendor.dbvmssql, GFmtOptFactory.newInstance()); 6905 sqLion.showLineNumber = true; 6906 sqLion.wholeUpper = true; 6907 String sql = "CREATE PROCEDURE dbo.uspUpdateEmployeeSales\r\n" 6908 + "AS\r\n" 6909 + " SET NOCOUNT ON;\r\n" 6910 + "\r\n" 6911 + " EXEC sp_rename 'dbo.EmployeeSales', 'FactEmployeeSales';\r\n" 6912 + "\r\n" 6913 + " INSERT INTO dbo.AggSales\r\n" 6914 + " SELECT LastName, SUM(SalesDollars) AS [Agg Sales]\r\n" 6915 + " FROM dbo.FactEmployeeSales\r\n" 6916 + " GROUP BY LastName;"; 6917 System.out.println(sql); 6918 sqLion.formatsqltext(sql); 6919 System.out.println(sqLion.getFormattedSQL()); 6920 } 6921 6922}