GFmtOpt (General SQL Parser Java Library Core 4.2.9 API)

Object
- gudusoft.gsqlparser.pp.para.GFmtOpt

```
public class GFmtOpt
extends Object
```
Mutable configuration for the SQL pretty-printer.
Create an instance with GFmtOptFactory, finish configuring it, and pass it to the formatter. Do not modify an instance while formatting is in progress. The formatter uses sessionId to associate processors and mediators with this option set.

Every public field is documented with its default and its interaction with related options. Fields in the "Lifecycle and advanced controls" category are public for compatibility but are not ordinary presentation settings.

Author:

zhoujun

Field Summary

Fields
Modifier and Type	Field and Description
`boolean`	`alignAliasInSelectList` Pads stacked SELECT expressions so their explicit or implicit aliases begin in the same column.
`boolean`	`alignJoinWithFromKeyword` Aligns the beginning of JOIN phrases with the FROM keyword rather than with the first table source.
`boolean`	`andOrUnderWhere` Aligns leading AND and OR operators under the WHERE keyword.
`Integer`	`beStyleBlockIndentSize` Adds indentation to statements inside BEGIN/END blocks and to returned query bodies in supported CREATE FUNCTION and CREATE VIEW forms.
`Integer`	`beStyleBlockLeftBEIndentSize` Adds columns to the containing statement's indentation for a BEGIN token moved to a new line.
`Boolean`	`beStyleBlockLeftBEOnNewline` Places a procedural BEGIN token on a new line.
`Integer`	`beStyleBlockRightBEIndentSize` Controls END indentation for block paths where BEGIN remains on the current line.
`boolean`	`beStyleCreatetableLeftBEOnNewline` Places the opening parenthesis of a CREATE TABLE column list on a new line and indents it by `indentLen`.
`boolean`	`beStyleCreatetableRightBEOnNewline` Places the closing parenthesis of a CREATE TABLE column list on its own line.
`Integer`	`beStyleFunctionBodyIndent` Reserved compatibility setting for stored-routine body indentation.
`Boolean`	`beStyleFunctionFirstParamInNewline` Places the first stored-routine parameter on a new line and indents it one general indentation level beyond its current parameter-list indentation.
`Integer`	`beStyleFunctionLeftBEIndentSize` Adds columns to the current indentation of a stored-routine opening parenthesis moved to a new line.
`Boolean`	`beStyleFunctionLeftBEOnNewline` Places the opening parenthesis of a stored-routine parameter list on a new line.
`Integer`	`beStyleFunctionRightBEIndentSize` Adds columns relative to the routine declaration when a parameter-list closing parenthesis is moved to a new line.
`Boolean`	`beStyleFunctionRightBEOnNewline` Places the closing parenthesis of a stored-routine parameter list on a new line.
`Integer`	`beStyleIfElseSingleStmtIndentSize` Adds indentation to a single statement controlled by IF or ELSE when the body is not represented as a BEGIN/END block.
`TCaseOption`	`caseDatatype` Converts tokens recognized as datatype names.
`TCaseOption`	`caseFuncname` Converts tokens recognized by the parser as function names, including built-in and user-defined calls where classification is available.
`TCaseOption`	`caseIdentifier` Converts unquoted identifier tokens that are not recognized as datatypes or function names.
`TCaseOption`	`caseKeywords` Converts SQL keyword tokens to the selected case.
`TCaseOption`	`caseQuotedIdentifier` Converts double-quoted identifier contents while preserving the quote characters.
`Boolean`	`caseWhenThenInSameLine` Keeps each WHEN condition and its THEN keyword on one line when true.
`TCompactMode`	`compactMode` Selects normal pretty-printing or compact output.
`TAlignOption`	`createtableFieldlistAlignOption` Left- or right-aligns CREATE TABLE column names within the widest column- name width.
`boolean`	`createtableListitemInNewLine` Places the first CREATE TABLE column or constraint on a new line after the opening parenthesis.
`Boolean`	`cteNewlineBeforeAs` Places the AS keyword of each common table expression on a new line aligned under the CTE name area.
`TAlignStyle`	`defaultAligntype` Provides stacked or wrapped layout for lists without a dedicated style, notably UPDATE SET and CREATE TABLE lists.
`TLinefeedsCommaOption`	`defaultCommaOption` Provides comma placement for formatter lists without a dedicated comma setting, including INSERT columns/values, UPDATE SET items, and CREATE TABLE columns and constraints.
`TEmptyLinesOption`	`emptyLines` Determines how blank lines found between top-level statements are handled: remove them, collapse them to one blank line, or preserve their count.
`boolean`	`fromClauseInNewLine` Places the first table source on a new indented line after FROM (and the corresponding INTO table source where that clause shares this processor).
`TLinefeedsCommaOption`	`functionCallParametersComma` Positions commas when ordinary function-call arguments use stacked layout.
`TAlignStyle`	`functionCallParametersStyle` Chooses stacked or wrapped layout for argument lists in ordinary function calls.
`Integer`	`indentCaseFromSwitch` Indents WHEN, ELSE, and END relative to the CASE keyword.
`Integer`	`indentCaseThen` Adds indentation to a line-broken THEN relative to its WHEN indentation.
`Integer`	`indentLen` Sets the general indentation increment, in columns, used by nested clauses, expressions, CTE bodies, parameters, and many statement processors.
`Boolean`	`insertBlankLineInBatchSqls` Inserts a blank line between statements inside supported BEGIN/END batches.
`TAlignStyle`	`insertColumnlistStyle` Chooses stacked or wrapped layout for the target-column list of INSERT.
`TAlignStyle`	`insertValuelistStyle` Chooses stacked or wrapped layout for each INSERT VALUES list.
`Boolean`	`linebreakAfterDeclare` Places the first variable declaration on a new indented line after DECLARE.
`Boolean`	`linebreakBeforeParamInExec` Places the first SQL Server EXEC/EXECUTE argument on a new line, indented by `indentLen` from the statement.
`Boolean`	`linenumberEnabled` Prefixes every output line with a zero-padded line number.
`Integer`	`linenumberLeftMargin` Inserts this many spaces before each generated line number.
`Integer`	`linenumberRightMargin` Inserts this many spaces between each generated line number and the SQL text.
`Boolean`	`linenumberZeroBased` Starts generated line numbers at zero when true, or one when false.
`Integer`	`lineWidth` Sets the maximum line width used by compact mode.
`Integer`	`maxSelectListColumn` Limits how many items are stacked at once in large SELECT-style lists.
`Boolean`	`noEmptyLinesBetweenMultiSetStmts` Suppresses the formatter's otherwise automatic blank line between adjacent SET or DECLARE-family statements.
`boolean`	`opearateSourceToken` Enables the low-level source-token mutation operations that implement formatting.
`GOutputFmt`	`outputFmt` Selects the renderer used after token formatting.
`TLinefeedsCommaOption`	`parametersComma` Positions commas for stacked stored-routine parameter declarations.
`TAlignStyle`	`parametersStyle` Chooses stacked or wrapped layout for stored-routine, package, trigger, and supported CREATE VIEW parameter declarations.
`Boolean`	`removeComment` Removes ordinary line and block comments before formatting and reparses the modified token stream.
`TLinefeedsCommaOption`	`selectColumnlistComma` Chooses whether a comma ends the previous line or begins the next line in stacked SELECT, GROUP BY, and ORDER BY lists.
`TAlignStyle`	`selectColumnlistStyle` Chooses stacked or wrapped layout for SELECT result columns and is also reused by GROUP BY and ORDER BY lists.
`TLinefeedsCommaOption`	`selectFromclauseComma` Positions commas for stacked comma-separated FROM items.
`boolean`	`selectFromclauseJoinOnInNewline` Places the ON condition of a JOIN on a separate line.
`TAlignStyle`	`selectFromclauseStyle` Chooses stacked or wrapped layout for comma-separated table sources in a FROM clause.
`boolean`	`selectItemInNewLine` Places the first SELECT item on a line after SELECT.
`TAlignOption`	`selectKeywordsAlignOption` Left- or right-aligns multiword and single-word query clause labels such as SELECT, FROM, WHERE, GROUP BY, HAVING, and ORDER BY within their shared keyword width.
`String`	`sessionId` Identifies the formatting session used by formatter, processor, and mediator caches.
`String`	`tabHtmlString` Replaces each literal tab in HTML output with this string.
`Integer`	`tabSize` Defines the tab-stop width used by the final tab-alignment pass when `useTab` is enabled.
`boolean`	`treatDistinctAsVirtualColumn` Adds a synthetic DISTINCT result-column node to the parsed SELECT list so it participates in stacking and comma-layout calculations.
`Boolean`	`useTab` Enables the final tab-alignment pass.
`Boolean`	`wsPaddingOperatorArithmetic` Inserts one space on both sides of recognized binary arithmetic and comparison operators.
`Boolean`	`wsPaddingParenthesesInExpression` Inserts one space just inside parentheses that group an expression, for example `( a + b )`.
`Boolean`	`wsPaddingParenthesesInFunction` Inserts one space just inside the parameter-list parentheses of CREATE FUNCTION, PROCEDURE, PACKAGE, and TRIGGER declarations when parameters are present.
`Boolean`	`wsPaddingParenthesesInFunctionCall` Inserts one space just inside ordinary function-call parentheses.
`Boolean`	`wsPaddingParenthesesOfSubQuery` Inserts one space just inside parentheses that enclose a formatted subquery.
`Boolean`	`wsPaddingParenthesesOfTypename` Inserts one space just inside datatype-parameter parentheses, for example `VARCHAR( 20 )`.

Constructor Summary

Constructors
Constructor and Description

GFmtOpt(String sessionId)
Creates an option set for the supplied formatting-session id.

Constructors
Constructor and Description
`GFmtOpt(String sessionId)` Creates an option set for the supplied formatting-session id.

Method Summary
- Methods inherited from class Object
  clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - sessionId
```
public final String sessionId
```
    Identifies the formatting session used by formatter, processor, and mediator caches. Use a unique id for independently configured concurrent calls; the id is not rendered in the output.
    Category: Lifecycle and advanced controls
    
    Default: Supplied to the constructor.
  - opearateSourceToken
```
public boolean opearateSourceToken
```
    Enables the low-level source-token mutation operations that implement formatting. Setting this to false makes token add/remove helpers ignore requests and therefore disables most formatting; it is intended for diagnostics, not as a preserve-layout mode.
    Category: Lifecycle and advanced controls
    
    Default: true.
  - selectColumnlistStyle
```
public TAlignStyle selectColumnlistStyle
```
    Chooses stacked or wrapped layout for SELECT result columns and is also reused by GROUP BY and ORDER BY lists. Stacked layout permits line breaks according to selectColumnlistComma; wrapped layout keeps items on the current line. Alias alignment is applied only to stacked lists.
    Category: SELECT list and query clauses
    
    Default: TAlignStyle.AsStacked.
  - selectColumnlistComma
```
public TLinefeedsCommaOption selectColumnlistComma
```
    Chooses whether a comma ends the previous line or begins the next line in stacked SELECT, GROUP BY, and ORDER BY lists. The setting has no line-break effect when selectColumnlistStyle is wrapped.
    Category: SELECT list and query clauses
    
    Default: TLinefeedsCommaOption.LfAfterComma.
  - selectItemInNewLine
```
public boolean selectItemInNewLine
```
    Places the first SELECT item on a line after SELECT. The same switch also places the first GROUP BY and ORDER BY item, and the HAVING expression, after their clause keywords; subsequent item breaks are controlled by the list style and comma option.
    Category: SELECT list and query clauses
    
    Default: false.
  - alignAliasInSelectList
```
public boolean alignAliasInSelectList
```
    Pads stacked SELECT expressions so their explicit or implicit aliases begin in the same column. It is ignored for wrapped lists and may be skipped for exceptionally wide lists to avoid excessive padding.
    Category: SELECT list and query clauses
    
    Default: true.
  - treatDistinctAsVirtualColumn
```
public boolean treatDistinctAsVirtualColumn
```
    Adds a synthetic DISTINCT result-column node to the parsed SELECT list so it participates in stacking and comma-layout calculations. This mutates the statement's result-column list for formatting, although the rendered SQL semantics are unchanged.
    Category: SELECT list and query clauses
    
    Default: false.
  - selectFromclauseStyle
```
public TAlignStyle selectFromclauseStyle
```
    Chooses stacked or wrapped layout for comma-separated table sources in a FROM clause. JOIN clauses have their own newline and alignment controls.
    Category: FROM, JOIN, and WHERE
    
    Default: TAlignStyle.AsStacked.
  - selectFromclauseComma
```
public TLinefeedsCommaOption selectFromclauseComma
```
    Positions commas for stacked comma-separated FROM items. It is effective only when selectFromclauseStyle is stacked.
    Category: FROM, JOIN, and WHERE
    
    Default: TLinefeedsCommaOption.LfAfterComma.
  - fromClauseInNewLine
```
public boolean fromClauseInNewLine
```
    Places the first table source on a new indented line after FROM (and the corresponding INTO table source where that clause shares this processor). When false, one space separates the clause keyword and first source.
    Category: FROM, JOIN, and WHERE
    
    Default: false.
  - selectFromclauseJoinOnInNewline
```
public boolean selectFromclauseJoinOnInNewline
```
    Places the ON condition of a JOIN on a separate line. JOIN keywords are always normalized onto their own lines by the JOIN processor; this switch controls the additional break before ON.
    Category: FROM, JOIN, and WHERE
    
    Default: true.
  - alignJoinWithFromKeyword
```
public boolean alignJoinWithFromKeyword
```
    Aligns the beginning of JOIN phrases with the FROM keyword rather than with the first table source. It does not control whether ON starts a new line; use selectFromclauseJoinOnInNewline for that.
    Category: FROM, JOIN, and WHERE
    
    Default: false.
  - andOrUnderWhere
```
public boolean andOrUnderWhere
```
    Aligns leading AND and OR operators under the WHERE keyword. When false, boolean continuations use the expression formatter's normal indentation.
    Category: FROM, JOIN, and WHERE
    
    Default: false.
  - insertColumnlistStyle
```
public TAlignStyle insertColumnlistStyle
```
    Chooses stacked or wrapped layout for the target-column list of INSERT. Comma placement comes from defaultCommaOption rather than the SELECT-specific comma option.
    Category: INSERT and general lists
    
    Default: TAlignStyle.AsStacked.
  - insertValuelistStyle
```
public TAlignStyle insertValuelistStyle
```
    Chooses stacked or wrapped layout for each INSERT VALUES list. Comma placement comes from defaultCommaOption.
    Category: INSERT and general lists
    
    Default: TAlignStyle.AsStacked.
  - beStyleCreatetableLeftBEOnNewline
```
public boolean beStyleCreatetableLeftBEOnNewline
```
    Places the opening parenthesis of a CREATE TABLE column list on a new line and indents it by indentLen. If list items are also placed on new lines, they receive one additional indentation level.
    Category: CREATE TABLE
    
    Default: false.
  - beStyleCreatetableRightBEOnNewline
```
public boolean beStyleCreatetableRightBEOnNewline
```
    Places the closing parenthesis of a CREATE TABLE column list on its own line. Its indentation accounts for whether the opening parenthesis was also moved to a new line.
    Category: CREATE TABLE
    
    Default: false.
  - createtableListitemInNewLine
```
public boolean createtableListitemInNewLine
```
    Places the first CREATE TABLE column or constraint on a new line after the opening parenthesis. Remaining items follow defaultAligntype and defaultCommaOption.
    Category: CREATE TABLE
    
    Default: false.
  - createtableFieldlistAlignOption
```
public TAlignOption createtableFieldlistAlignOption
```
    Left- or right-aligns CREATE TABLE column names within the widest column- name width. It is applied only when defaultAligntype is stacked.
    Category: CREATE TABLE
    
    Default: TAlignOption.AloLeft.
  - defaultCommaOption
```
public TLinefeedsCommaOption defaultCommaOption
```
    Provides comma placement for formatter lists without a dedicated comma setting, including INSERT columns/values, UPDATE SET items, and CREATE TABLE columns and constraints.
    Category: INSERT and general lists
    
    Default: TLinefeedsCommaOption.LfAfterComma.
  - defaultAligntype
```
public TAlignStyle defaultAligntype
```
    Provides stacked or wrapped layout for lists without a dedicated style, notably UPDATE SET and CREATE TABLE lists. INSERT has separate style fields but still uses defaultCommaOption for commas.
    Category: INSERT and general lists
    
    Default: TAlignStyle.AsStacked.
  - indentLen
```
public Integer indentLen
```
    Sets the general indentation increment, in columns, used by nested clauses, expressions, CTE bodies, parameters, and many statement processors. More specialized indentation options add to, rather than replace, this value.
    Category: Indentation and procedural blocks
    
    Default: 2.
  - useTab
```
public Boolean useTab
```
    Enables the final tab-alignment pass. The formatter first computes spaces, then pads each indented line to a multiple of tabSize; this option does not replace all indentation characters with literal tab characters.
    Category: Indentation and procedural blocks
    
    Default: false.
  - tabSize
```
public Integer tabSize
```
    Defines the tab-stop width used by the final tab-alignment pass when useTab is enabled. Use a positive value.
    Category: Indentation and procedural blocks
    
    Default: 2.
  - beStyleFunctionBodyIndent
```
public Integer beStyleFunctionBodyIndent
```
    Reserved compatibility setting for stored-routine body indentation. The active formatter currently does not read this field; use beStyleBlockIndentSize and indentLen for effective body indentation.
    Category: Indentation and procedural blocks
    
    Default: 2; currently has no effect.
  - beStyleBlockLeftBEOnNewline
```
public Boolean beStyleBlockLeftBEOnNewline
```
    Places a procedural BEGIN token on a new line. This is used by PL/SQL-like blocks and by SQL Server BEGIN/END block formatting, with vendor-specific paths applying the related indentation settings.
    Category: Indentation and procedural blocks
    
    Default: true.
  - beStyleBlockLeftBEIndentSize
```
public Integer beStyleBlockLeftBEIndentSize
```
    Adds columns to the containing statement's indentation for a BEGIN token moved to a new line. It is meaningful when beStyleBlockLeftBEOnNewline is true.
    Category: Indentation and procedural blocks
    
    Default: 2.
  - beStyleBlockRightBEIndentSize
```
public Integer beStyleBlockRightBEIndentSize
```
    Controls END indentation for block paths where BEGIN remains on the current line. When BEGIN is moved, those paths align END using the BEGIN indent instead, so this value may be ignored.
    Category: Indentation and procedural blocks
    
    Default: 2.
  - beStyleBlockIndentSize
```
public Integer beStyleBlockIndentSize
```
    Adds indentation to statements inside BEGIN/END blocks and to returned query bodies in supported CREATE FUNCTION and CREATE VIEW forms. It is measured relative to the enclosing block marker.
    Category: Indentation and procedural blocks
    
    Default: 2.
  - beStyleIfElseSingleStmtIndentSize
```
public Integer beStyleIfElseSingleStmtIndentSize
```
    Adds indentation to a single statement controlled by IF or ELSE when the body is not represented as a BEGIN/END block. Block bodies instead use the block indentation options.
    Category: Indentation and procedural blocks
    
    Default: 2.
  - caseWhenThenInSameLine
```
public Boolean caseWhenThenInSameLine
```
    Keeps each WHEN condition and its THEN keyword on one line when true. When false, THEN starts a new line and its indentation additionally uses indentCaseThen.
    Category: CASE expressions
    
    Default: false.
  - indentCaseFromSwitch
```
public Integer indentCaseFromSwitch
```
    Indents WHEN, ELSE, and END relative to the CASE keyword. The value is an absolute number of columns added at that CASE nesting level.
    Category: CASE expressions
    
    Default: 2.
  - indentCaseThen
```
public Integer indentCaseThen
```
    Adds indentation to a line-broken THEN relative to its WHEN indentation. It is ignored when caseWhenThenInSameLine is true.
    Category: CASE expressions
    
    Default: 0.
  - selectKeywordsAlignOption
```
public TAlignOption selectKeywordsAlignOption
```
    Left- or right-aligns multiword and single-word query clause labels such as SELECT, FROM, WHERE, GROUP BY, HAVING, and ORDER BY within their shared keyword width.
    Category: Keyword alignment and capitalization
    
    Default: TAlignOption.AloLeft.
  - caseKeywords
```
public TCaseOption caseKeywords
```
    Converts SQL keyword tokens to the selected case. Datatypes and recognized function names use their dedicated case settings instead.
    Category: Keyword alignment and capitalization
    
    Default: TCaseOption.CoUppercase.
  - caseIdentifier
```
public TCaseOption caseIdentifier
```
    Converts unquoted identifier tokens that are not recognized as datatypes or function names. Changing case can change semantics in case-sensitive databases, so preserve case unless that transformation is intentional.
    Category: Keyword alignment and capitalization
    
    Default: TCaseOption.CoNoChange.
  - caseQuotedIdentifier
```
public TCaseOption caseQuotedIdentifier
```
    Converts double-quoted identifier contents while preserving the quote characters. Quoted identifiers are frequently case-sensitive; use any value other than no-change with care.
    Category: Keyword alignment and capitalization
    
    Default: TCaseOption.CoNoChange.
  - caseFuncname
```
public TCaseOption caseFuncname
```
    Converts tokens recognized by the parser as function names, including built-in and user-defined calls where classification is available.
    Category: Keyword alignment and capitalization
    
    Default: TCaseOption.CoInitCap.
  - caseDatatype
```
public TCaseOption caseDatatype
```
    Converts tokens recognized as datatype names. This classification takes precedence over the general keyword and identifier case settings.
    Category: Keyword alignment and capitalization
    
    Default: TCaseOption.CoUppercase.
  - wsPaddingOperatorArithmetic
```
public Boolean wsPaddingOperatorArithmetic
```
    Inserts one space on both sides of recognized binary arithmetic and comparison operators. Unary plus and minus are kept adjacent to their operand regardless of this setting.
    Category: Whitespace and parentheses
    
    Default: true.
  - wsPaddingParenthesesInFunction
```
public Boolean wsPaddingParenthesesInFunction
```
    Inserts one space just inside the parameter-list parentheses of CREATE FUNCTION, PROCEDURE, PACKAGE, and TRIGGER declarations when parameters are present. It does not affect ordinary function calls.
    Category: Whitespace and parentheses
    
    Default: false.
  - wsPaddingParenthesesInExpression
```
public Boolean wsPaddingParenthesesInExpression
```
    Inserts one space just inside parentheses that group an expression, for example ( a + b ). Subqueries, function calls, and datatype parameters use separate options.
    Category: Whitespace and parentheses
    
    Default: true.
  - wsPaddingParenthesesOfSubQuery
```
public Boolean wsPaddingParenthesesOfSubQuery
```
    Inserts one space just inside parentheses that enclose a formatted subquery. Internal subquery line breaks and indentation are still produced by the nested statement formatter.
    Category: Whitespace and parentheses
    
    Default: false.
  - wsPaddingParenthesesInFunctionCall
```
public Boolean wsPaddingParenthesesInFunctionCall
```
    Inserts one space just inside ordinary function-call parentheses. Stored- routine declaration parentheses use wsPaddingParenthesesInFunction instead.
    Category: Whitespace and parentheses
    
    Default: false.
  - wsPaddingParenthesesOfTypename
```
public Boolean wsPaddingParenthesesOfTypename
```
    Inserts one space just inside datatype-parameter parentheses, for example VARCHAR( 20 ). It applies only when the parser classifies the node as a type name.
    Category: Whitespace and parentheses
    
    Default: false.
  - cteNewlineBeforeAs
```
public Boolean cteNewlineBeforeAs
```
    Places the AS keyword of each common table expression on a new line aligned under the CTE name area. When false, AS follows the CTE header after one space; the CTE query itself is formatted in both cases.
    Category: CTEs and declarations
    
    Default: true.
  - linebreakAfterDeclare
```
public Boolean linebreakAfterDeclare
```
    Places the first variable declaration on a new indented line after DECLARE. Later declaration items are always stacked by the DECLARE formatter.
    Category: CTEs and declarations
    
    Default: false.
  - parametersStyle
```
public TAlignStyle parametersStyle
```
    Chooses stacked or wrapped layout for stored-routine, package, trigger, and supported CREATE VIEW parameter declarations. Stacked parameters also have their names/types aligned by the parameter formatter.
    Category: Routine declarations and EXEC
    
    Default: TAlignStyle.AsStacked.
  - parametersComma
```
public TLinefeedsCommaOption parametersComma
```
    Positions commas for stacked stored-routine parameter declarations. It is effective when parametersStyle is stacked.
    Category: Routine declarations and EXEC
    
    Default: TLinefeedsCommaOption.LfAfterComma.
  - beStyleFunctionLeftBEOnNewline
```
public Boolean beStyleFunctionLeftBEOnNewline
```
    Places the opening parenthesis of a stored-routine parameter list on a new line. The setting applies only when a parameter declaration list exists.
    Category: Routine declarations and EXEC
    
    Default: false.
  - beStyleFunctionLeftBEIndentSize
```
public Integer beStyleFunctionLeftBEIndentSize
```
    Adds columns to the current indentation of a stored-routine opening parenthesis moved to a new line. It is ignored unless beStyleFunctionLeftBEOnNewline is true.
    Category: Routine declarations and EXEC
    
    Default: 0.
  - beStyleFunctionRightBEOnNewline
```
public Boolean beStyleFunctionRightBEOnNewline
```
    Places the closing parenthesis of a stored-routine parameter list on a new line. The setting applies only when a parameter declaration list exists.
    Category: Routine declarations and EXEC
    
    Default: true.
  - beStyleFunctionRightBEIndentSize
```
public Integer beStyleFunctionRightBEIndentSize
```
    Adds columns relative to the routine declaration when a parameter-list closing parenthesis is moved to a new line. It is ignored unless beStyleFunctionRightBEOnNewline is true.
    Category: Routine declarations and EXEC
    
    Default: 0.
  - beStyleFunctionFirstParamInNewline
```
public Boolean beStyleFunctionFirstParamInNewline
```
    Places the first stored-routine parameter on a new line and indents it one general indentation level beyond its current parameter-list indentation. Subsequent parameters follow the parameter style and comma settings.
    Category: Routine declarations and EXEC
    
    Default: false.
  - linebreakBeforeParamInExec
```
public Boolean linebreakBeforeParamInExec
```
    Places the first SQL Server EXEC/EXECUTE argument on a new line, indented by indentLen from the statement. It does not control stored-routine declaration parameters.
    Category: Routine declarations and EXEC
    
    Default: true.
  - emptyLines
```
public TEmptyLinesOption emptyLines
```
    Determines how blank lines found between top-level statements are handled: remove them, collapse them to one blank line, or preserve their count. Statement-separating newlines themselves are always retained.
    Category: Blank lines and batches
    
    Default: TEmptyLinesOption.EloMergeIntoOne.
  - insertBlankLineInBatchSqls
```
public Boolean insertBlankLineInBatchSqls
```
    Inserts a blank line between statements inside supported BEGIN/END batches. It is applied in addition to the general emptyLines policy.
    Category: Blank lines and batches
    
    Default: false.
  - noEmptyLinesBetweenMultiSetStmts
```
public Boolean noEmptyLinesBetweenMultiSetStmts
```
    Suppresses the formatter's otherwise automatic blank line between adjacent SET or DECLARE-family statements. It does not remove ordinary separator newlines and does not override unrelated batch blank-line insertion.
    Category: Blank lines and batches
    
    Default: false.
  - linenumberEnabled
```
public Boolean linenumberEnabled
```
    Prefixes every output line with a zero-padded line number. Width is based on the total formatted line count; margins are controlled by the line-number margin settings.
    Category: Line numbers
    
    Default: false.
  - linenumberZeroBased
```
public Boolean linenumberZeroBased
```
    Starts generated line numbers at zero when true, or one when false. It has no effect unless linenumberEnabled is enabled.
    Category: Line numbers
    
    Default: false (one-based numbering).
  - linenumberLeftMargin
```
public Integer linenumberLeftMargin
```
    Inserts this many spaces before each generated line number. It has no effect unless linenumberEnabled is enabled.
    Category: Line numbers
    
    Default: 0.
  - linenumberRightMargin
```
public Integer linenumberRightMargin
```
    Inserts this many spaces between each generated line number and the SQL text. It has no effect unless linenumberEnabled is enabled.
    Category: Line numbers
    
    Default: 2.
  - functionCallParametersStyle
```
public TAlignStyle functionCallParametersStyle
```
    Chooses stacked or wrapped layout for argument lists in ordinary function calls. This is independent from the stored-routine declaration parameter style.
    Category: Function calls
    
    Default: TAlignStyle.AsWrapped.
  - functionCallParametersComma
```
public TLinefeedsCommaOption functionCallParametersComma
```
    Positions commas when ordinary function-call arguments use stacked layout. It has no line-break effect while functionCallParametersStyle is wrapped.
    Category: Function calls
    
    Default: TLinefeedsCommaOption.LfAfterComma.
  - removeComment
```
public Boolean removeComment
```
    Removes ordinary line and block comments before formatting and reparses the modified token stream. Oracle optimizer hints beginning with /*+ are preserved. Because removal mutates the parser's token list, use a fresh parser if the original comments are needed later.
    Category: Comments, compact mode, and wrapping
    
    Default: false.
  - compactMode
```
public TCompactMode compactMode
```
    Selects normal pretty-printing or compact output. Cpmugly short-circuits statement-specific layout, normalizes the token stream, and wraps only when lineWidth is exceeded; most other layout options are therefore ignored.
    Category: Comments, compact mode, and wrapping
    
    Default: TCompactMode.CpmNone.
  - lineWidth
```
public Integer lineWidth
```
    Sets the maximum line width used by compact mode. It is a soft limit: indivisible tokens longer than the value can still exceed it. The active normal pretty-printing pipeline does not currently use this field.
    Category: Comments, compact mode, and wrapping
    
    Default: 99.
  - maxSelectListColumn
```
public Integer maxSelectListColumn
```
    Limits how many items are stacked at once in large SELECT-style lists. When a list exceeds the threshold, the comma processor packs several items per line up to lineWidth (a comment ends the line, and an item that spans lines gets a line of its own) and alias alignment is skipped; use Integer.MAX_VALUE to disable the threshold.
    Category: Comments, compact mode, and wrapping
    
    Default: 20. This option is available only in GSP Java.
  - outputFmt
```
public GOutputFmt outputFmt
```
    Selects the renderer used after token formatting. The active formatter supports GOutputFmt.ofSql and GOutputFmt.ofhtml; GOutputFmt.ofUnknown falls back to SQL, while the other legacy enum values currently throw UnsupportedOperationException. After HTML output initializes the static renderer, later FormatterFactory.pp calls reuse it until FormatterFactory.setOutputConfig(null) is called.
    Category: Output rendering
    
    Default: GOutputFmt.ofSql.
    
    See Also:
    
    GOutputFmt
  - tabHtmlString
```
public String tabHtmlString
```
    Replaces each literal tab in HTML output with this string. It is used only by the Java HTML renderer (outputFmt == ofhtml) and is independent of the tab-stop calculation controlled by useTab and tabSize.
    Category: Output rendering
    
    Default: "&nbsp;&nbsp;&nbsp;&nbsp;".
- Constructor Detail
  - GFmtOpt
```
public GFmtOpt(String sessionId)
```
    Creates an option set for the supplied formatting-session id.
    
    Parameters:
    
    sessionId - cache key shared by components in one formatting call

Class GFmtOpt

Field Summary

Constructor Summary

Method Summary

Methods inherited from class Object

Field Detail

sessionId

opearateSourceToken

selectColumnlistStyle

selectColumnlistComma

selectItemInNewLine

alignAliasInSelectList

treatDistinctAsVirtualColumn

selectFromclauseStyle

selectFromclauseComma

fromClauseInNewLine

selectFromclauseJoinOnInNewline

alignJoinWithFromKeyword

andOrUnderWhere

insertColumnlistStyle

insertValuelistStyle

beStyleCreatetableLeftBEOnNewline

beStyleCreatetableRightBEOnNewline

createtableListitemInNewLine

createtableFieldlistAlignOption

defaultCommaOption

defaultAligntype

indentLen

useTab

tabSize

beStyleFunctionBodyIndent

beStyleBlockLeftBEOnNewline

beStyleBlockLeftBEIndentSize

beStyleBlockRightBEIndentSize

beStyleBlockIndentSize

beStyleIfElseSingleStmtIndentSize

caseWhenThenInSameLine

indentCaseFromSwitch

indentCaseThen

selectKeywordsAlignOption

caseKeywords

caseIdentifier

caseQuotedIdentifier

caseFuncname

caseDatatype

wsPaddingOperatorArithmetic

wsPaddingParenthesesInFunction

wsPaddingParenthesesInExpression

wsPaddingParenthesesOfSubQuery

wsPaddingParenthesesInFunctionCall

wsPaddingParenthesesOfTypename

cteNewlineBeforeAs

linebreakAfterDeclare

parametersStyle

parametersComma

beStyleFunctionLeftBEOnNewline

beStyleFunctionLeftBEIndentSize

beStyleFunctionRightBEOnNewline

beStyleFunctionRightBEIndentSize

beStyleFunctionFirstParamInNewline

linebreakBeforeParamInExec

emptyLines

insertBlankLineInBatchSqls

noEmptyLinesBetweenMultiSetStmts

linenumberEnabled

linenumberZeroBased

linenumberLeftMargin

linenumberRightMargin

functionCallParametersStyle

functionCallParametersComma

removeComment

compactMode

lineWidth

maxSelectListColumn

outputFmt

tabHtmlString

Constructor Detail

GFmtOpt