perf: optimize AbstractFormatter using StringBuilder and static Regex

hogimn · hogimn · commit eb569f921c13 · 2026-05-01T20:14:22.000+09:00
- Replace string concatenation with StringBuilder to reduce GC pressure
- Use statically compiled Regex to avoid recompilation overhead
- Implement O(1) TrimEnd by direct StringBuilder.Length adjustment

Benchmark (100 runs):
- Mean: 76.09ms -&gt; 69.46ms (-8.7%)
- Allocated: 70.7MB -&gt; 67.5MB (-4.6%)
- Gen 0 GC: 11,333 -&gt; 10,666 (-5.9%)
diff --git a/SQL.Formatter/Core/AbstractFormatter.cs b/SQL.Formatter/Core/AbstractFormatter.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Text;
 using System.Text.RegularExpressions;
 using SQL.Formatter.Core.Util;
 using SQL.Formatter.Language;
@@ -16,6 +17,19 @@ public class AbstractFormatter : IDialectConfigurator
         private JSLikeList<Token> _tokens;
         private int _index;
 
+        // OPTIMIZATION: Compile the regex once statically to prevent recompilation overhead
+        private static readonly Regex s_whitespaceRegex = new Regex(@"\s+", RegexOptions.Compiled);
+
+        private static readonly HashSet<TokenTypes> s_preserveWhitespaceFor =
+            new HashSet<TokenTypes> {
+                TokenTypes.OPEN_PAREN,
+                TokenTypes.LINE_COMMENT,
+                TokenTypes.OPERATOR,
+                TokenTypes.RESERVED_NEWLINE
+            };
+
+        public Func<DialectConfig> _doDialectConfigFunc;
+
         public AbstractFormatter(FormatConfig cfg)
         {
             _cfg = cfg;
@@ -41,152 +55,149 @@ protected virtual Token TokenOverride(Token token)
         public string Format(string query)
         {
             _tokens = Tokenizer().Tokenize(query);
-            var formattedQuery = GetFormattedQueryFromTokens();
-
-            return formattedQuery.Trim();
+            return GetFormattedQueryFromTokens().Trim();
         }
 
         private string GetFormattedQueryFromTokens()
         {
-            var formattedQuery = string.Empty;
+            // OPTIMIZATION: Use a StringBuilder initialized with an estimated capacity to prevent resizing.
+            // If you know average query sizes, set this capacity accordingly.
+            var formattedQuery = new StringBuilder(1024);
 
             var index = -1;
             foreach (Token t in _tokens)
             {
                 _index = ++index;
-
                 var token = TokenOverride(t);
 
                 if (token.Type == TokenTypes.LINE_COMMENT)
                 {
-                    formattedQuery = FormatLineComment(token, formattedQuery);
+                    FormatLineComment(token, formattedQuery);
                 }
                 else if (token.Type == TokenTypes.BLOCK_COMMENT)
                 {
-                    formattedQuery = FormatBlockComment(token, formattedQuery);
+                    FormatBlockComment(token, formattedQuery);
                 }
                 else if (token.Type == TokenTypes.RESERVED_TOP_LEVEL)
                 {
-                    formattedQuery = FormatToplevelReservedWord(token, formattedQuery);
+                    FormatToplevelReservedWord(token, formattedQuery);
                     _previousReservedToken = token;
                 }
                 else if (token.Type == TokenTypes.RESERVED_TOP_LEVEL_NO_INDENT)
                 {
-                    formattedQuery = FormatTopLevelReservedWordNoIndent(token, formattedQuery);
+                    FormatTopLevelReservedWordNoIndent(token, formattedQuery);
                     _previousReservedToken = token;
                 }
                 else if (token.Type == TokenTypes.RESERVED_NEWLINE)
                 {
-                    formattedQuery = FormatNewlineReservedWord(token, formattedQuery);
+                    FormatNewlineReservedWord(token, formattedQuery);
                     _previousReservedToken = token;
                 }
                 else if (token.Type == TokenTypes.RESERVED)
                 {
-                    formattedQuery = FormatWithSpaces(token, formattedQuery);
+                    FormatWithSpaces(token, formattedQuery);
                     _previousReservedToken = token;
                 }
                 else if (token.Type == TokenTypes.OPEN_PAREN)
                 {
-                    formattedQuery = FormatOpeningParentheses(token, formattedQuery);
+                    FormatOpeningParentheses(token, formattedQuery);
                 }
                 else if (token.Type == TokenTypes.CLOSE_PAREN)
                 {
-                    formattedQuery = FormatClosingParentheses(token, formattedQuery);
+                    FormatClosingParentheses(token, formattedQuery);
                 }
                 else if (token.Type == TokenTypes.PLACEHOLDER)
                 {
-                    formattedQuery = FormatPlaceholder(token, formattedQuery);
+                    FormatPlaceholder(token, formattedQuery);
                 }
                 else if (token.Value.Equals(","))
                 {
-                    formattedQuery = FormatComma(token, formattedQuery);
+                    FormatComma(token, formattedQuery);
                 }
                 else if (token.Value.Equals(":"))
                 {
-                    formattedQuery = FormatWithSpaceAfter(token, formattedQuery);
+                    FormatWithSpaceAfter(token, formattedQuery);
                 }
                 else if (token.Value.Equals("."))
                 {
-                    formattedQuery = FormatWithoutSpaces(token, formattedQuery);
+                    FormatWithoutSpaces(token, formattedQuery);
                 }
                 else if (token.Value.Equals(";"))
                 {
-                    formattedQuery = FormatQuerySeparator(token, formattedQuery);
+                    FormatQuerySeparator(token, formattedQuery);
                 }
                 else
                 {
-                    formattedQuery = FormatWithSpaces(token, formattedQuery);
+                    FormatWithSpaces(token, formattedQuery);
                 }
             }
 
-            return formattedQuery;
+            return formattedQuery.ToString();
         }
 
-        protected virtual string FormatLineComment(Token token, string query)
+        protected virtual void FormatLineComment(Token token, StringBuilder query)
         {
-            return AddNewline(query + Show(token));
+            query.Append(Show(token));
+            AddNewline(query);
         }
 
-        protected virtual string FormatBlockComment(Token token, string query)
+        protected virtual void FormatBlockComment(Token token, StringBuilder query)
         {
-            return AddNewline(AddNewline(query) + IndentComment(token.Value));
+            AddNewline(query);
+            query.Append(IndentComment(token.Value));
+            AddNewline(query);
         }
 
         protected virtual string IndentComment(string comment)
         {
             return comment.Replace("\n", "\n" + _indentation.GetIndent());
         }
 
-        protected virtual string FormatTopLevelReservedWordNoIndent(Token token, string query)
+        protected virtual void FormatTopLevelReservedWordNoIndent(Token token, StringBuilder query)
         {
             _indentation.DecreaseTopLevel();
-            query = AddNewline(query) + EqualizeWhitespace(Show(token));
-            return AddNewline(query);
+            AddNewline(query);
+            query.Append(EqualizeWhitespace(Show(token)));
+            AddNewline(query);
         }
 
-        protected virtual string FormatToplevelReservedWord(Token token, string query)
+        protected virtual void FormatToplevelReservedWord(Token token, StringBuilder query)
         {
             _indentation.DecreaseTopLevel();
-
-            query = AddNewline(query);
-
+            AddNewline(query);
             _indentation.IncreaseTopLevel();
 
-            query += EqualizeWhitespace(Show(token));
-            return AddNewline(query);
+            query.Append(EqualizeWhitespace(Show(token)));
+            AddNewline(query);
         }
 
-        protected virtual string FormatNewlineReservedWord(Token token, string query)
+        protected virtual void FormatNewlineReservedWord(Token token, StringBuilder query)
         {
             if (Token.IsAnd(token) && Token.IsBetween(TokenLookBehind(2)))
             {
-                return FormatWithSpaces(token, query);
+                FormatWithSpaces(token, query);
+                return;
             }
 
-            return AddNewline(query) + EqualizeWhitespace(Show(token)) + " ";
+            AddNewline(query);
+            query.Append(EqualizeWhitespace(Show(token))).Append(" ");
         }
 
         protected static string EqualizeWhitespace(string str)
         {
-            return Regex.Replace(str, @"\s+", " ");
+            // Uses the statically compiled regex
+            return s_whitespaceRegex.Replace(str, " ");
         }
 
-        private static readonly HashSet<TokenTypes> s_preserveWhitespaceFor =
-            new HashSet<TokenTypes> {
-                TokenTypes.OPEN_PAREN,
-                TokenTypes.LINE_COMMENT,
-                TokenTypes.OPERATOR,
-                TokenTypes.RESERVED_NEWLINE};
-
-        protected virtual string FormatOpeningParentheses(Token token, string query)
+        protected virtual void FormatOpeningParentheses(Token token, StringBuilder query)
         {
             if (string.IsNullOrEmpty(token.WhitespaceBefore)
                 && (TokenLookBehind() == default || !s_preserveWhitespaceFor.Contains(TokenLookBehind().Type)))
             {
-                query = query.TrimEnd();
+                TrimEnd(query);
             }
 
-            query += Show(token);
+            query.Append(Show(token));
 
             _inlineBlock.BeginIfPossible(_tokens, _index);
 
@@ -195,65 +206,78 @@ protected virtual string FormatOpeningParentheses(Token token, string query)
                 _indentation.IncreaseBlockLevel();
                 if (!_cfg.SkipWhitespaceNearBlockParentheses)
                 {
-                    query = AddNewline(query);
+                    AddNewline(query);
                 }
             }
-
-            return query;
         }
 
-        protected virtual string FormatClosingParentheses(Token token, string query)
+        protected virtual void FormatClosingParentheses(Token token, StringBuilder query)
         {
             if (_inlineBlock.IsActive())
             {
                 _inlineBlock.End();
-                return FormatWithSpaceAfter(token, query);
+                FormatWithSpaceAfter(token, query);
             }
             else
             {
                 _indentation.DecreaseBlockLevel();
 
                 if (!_cfg.SkipWhitespaceNearBlockParentheses)
                 {
-                    return FormatWithSpaces(token, AddNewline(query));
+                    AddNewline(query);
+                    FormatWithSpaces(token, query);
+                }
+                else
+                {
+                    FormatWithoutSpaces(token, query);
                 }
-
-                return FormatWithoutSpaces(token, query);
             }
         }
 
-        protected virtual string FormatPlaceholder(Token token, string query)
+        protected virtual void FormatPlaceholder(Token token, StringBuilder query)
         {
-            return query + _parameters.Get(token) + " ";
+            query.Append(_parameters.Get(token)).Append(" ");
         }
 
-        protected virtual string FormatComma(Token token, string query)
+        protected virtual void FormatComma(Token token, StringBuilder query)
         {
-            query = query.TrimEnd() + Show(token) + " ";
-            return _inlineBlock.IsActive() || Token.IsLimit(_previousReservedToken) ? query : AddNewline(query);
+            TrimEnd(query);
+            query.Append(Show(token)).Append(" ");
+
+            if (!_inlineBlock.IsActive() && !Token.IsLimit(_previousReservedToken))
+            {
+                AddNewline(query);
+            }
         }
 
-        protected virtual string FormatWithSpaceAfter(Token token, string query)
+        protected virtual void FormatWithSpaceAfter(Token token, StringBuilder query)
         {
-            return query.TrimEnd() + Show(token) + " ";
+            TrimEnd(query);
+            query.Append(Show(token)).Append(" ");
         }
 
-        protected virtual string FormatWithoutSpaces(Token token, string query)
+        protected virtual void FormatWithoutSpaces(Token token, StringBuilder query)
         {
-            return query.TrimEnd() + Show(token);
+            TrimEnd(query);
+            query.Append(Show(token));
         }
 
-        protected virtual string FormatWithSpaces(Token token, string query)
+        protected virtual void FormatWithSpaces(Token token, StringBuilder query)
         {
-            return query + Show(token) + " ";
+            query.Append(Show(token)).Append(" ");
         }
 
-        protected virtual string FormatQuerySeparator(Token token, string query)
+        protected virtual void FormatQuerySeparator(Token token, StringBuilder query)
         {
             _indentation.ResetIndentation();
-            return query.TrimEnd()
-                + Show(token)
-                + Utils.Repeat("\n", _cfg.LinesBetweenQueries == default ? 1 : _cfg.LinesBetweenQueries);
+            TrimEnd(query);
+            query.Append(Show(token));
+
+            var lines = _cfg.LinesBetweenQueries == default ? 1 : _cfg.LinesBetweenQueries;
+            for (var i = 0; i < lines; i++)
+            {
+                query.Append('\n');
+            }
         }
 
         protected virtual string Show(Token token)
@@ -266,49 +290,42 @@ protected virtual string Show(Token token)
                     || token.Type == TokenTypes.OPEN_PAREN
                     || token.Type == TokenTypes.CLOSE_PAREN))
             {
+                // Note: If memory is still tight, caching upper-case values at the token generation stage is even better.
                 return token.Value.ToUpper();
             }
 
             return token.Value;
         }
 
-        protected virtual string AddNewline(string query)
+        protected virtual void AddNewline(StringBuilder query)
         {
-            query = query.TrimEnd();
-            if (!query.EndsWith("\n"))
+            TrimEnd(query);
+            // Replaces expensive .EndsWith("\n") with a fast char index lookup
+            if (query.Length == 0 || query[query.Length - 1] != '\n')
             {
-                query += "\n";
+                query.Append('\n');
             }
 
-            return query + _indentation.GetIndent();
-        }
-
-        protected Token TokenLookBehind()
-        {
-            return TokenLookBehind(1);
+            query.Append(_indentation.GetIndent());
         }
 
-        protected Token TokenLookBehind(int n)
+        // OPTIMIZATION: Extremely fast inline trailing whitespace removal
+        protected void TrimEnd(StringBuilder sb)
         {
-            return _tokens.Get(_index - n);
-        }
-
-        protected Token TokenLookAhead()
-        {
-            return TokenLookAhead(1);
+            while (sb.Length > 0 && char.IsWhiteSpace(sb[sb.Length - 1]))
+            {
+                sb.Length--;
+            }
         }
 
-        protected Token TokenLookAhead(int n)
-        {
-            return _tokens.Get(_index + n);
-
-        }
+        protected Token TokenLookBehind() => TokenLookBehind(1);
+        protected Token TokenLookBehind(int n) => _tokens.Get(_index - n);
+        protected Token TokenLookAhead() => TokenLookAhead(1);
+        protected Token TokenLookAhead(int n) => _tokens.Get(_index + n);
 
         public virtual DialectConfig DoDialectConfig()
         {
             return _doDialectConfigFunc.Invoke();
         }
-
-        public Func<DialectConfig> _doDialectConfigFunc;
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Text;`
`3`	`4`	`using System.Text.RegularExpressions;`
`4`	`5`	`using SQL.Formatter.Core.Util;`
`5`	`6`	`using SQL.Formatter.Language;`
`@@ -16,6 +17,19 @@ public class AbstractFormatter : IDialectConfigurator`
`16`	`17`	`private JSLikeList<Token> _tokens;`
`17`	`18`	`private int _index;`
`18`	`19`
	`20`	`+ // OPTIMIZATION: Compile the regex once statically to prevent recompilation overhead`
	`21`	`+ private static readonly Regex s_whitespaceRegex = new Regex(@"\s+", RegexOptions.Compiled);`
	`22`	`+`
	`23`	`+ private static readonly HashSet<TokenTypes> s_preserveWhitespaceFor =`
	`24`	`+ new HashSet<TokenTypes> {`
	`25`	`+ TokenTypes.OPEN_PAREN,`
	`26`	`+ TokenTypes.LINE_COMMENT,`
	`27`	`+ TokenTypes.OPERATOR,`
	`28`	`+ TokenTypes.RESERVED_NEWLINE`
	`29`	`+ };`
	`30`	`+`
	`31`	`+ public Func<DialectConfig> _doDialectConfigFunc;`
	`32`	`+`
`19`	`33`	`public AbstractFormatter(FormatConfig cfg)`
`20`	`34`	`{`
`21`	`35`	`_cfg = cfg;`
`@@ -41,152 +55,149 @@ protected virtual Token TokenOverride(Token token)`
`41`	`55`	`public string Format(string query)`
`42`	`56`	`{`
`43`	`57`	`_tokens = Tokenizer().Tokenize(query);`
`44`		`- var formattedQuery = GetFormattedQueryFromTokens();`
`45`		`-`
`46`		`- return formattedQuery.Trim();`
	`58`	`+ return GetFormattedQueryFromTokens().Trim();`
`47`	`59`	`}`
`48`	`60`
`49`	`61`	`private string GetFormattedQueryFromTokens()`
`50`	`62`	`{`
`51`		`- var formattedQuery = string.Empty;`
	`63`	`+ // OPTIMIZATION: Use a StringBuilder initialized with an estimated capacity to prevent resizing.`
	`64`	`+ // If you know average query sizes, set this capacity accordingly.`
	`65`	`+ var formattedQuery = new StringBuilder(1024);`
`52`	`66`
`53`	`67`	`var index = -1;`
`54`	`68`	`foreach (Token t in _tokens)`
`55`	`69`	`{`
`56`	`70`	`_index = ++index;`
`57`		`-`
`58`	`71`	`var token = TokenOverride(t);`
`59`	`72`
`60`	`73`	`if (token.Type == TokenTypes.LINE_COMMENT)`
`61`	`74`	`{`
`62`		`- formattedQuery = FormatLineComment(token, formattedQuery);`
	`75`	`+ FormatLineComment(token, formattedQuery);`
`63`	`76`	`}`
`64`	`77`	`else if (token.Type == TokenTypes.BLOCK_COMMENT)`
`65`	`78`	`{`
`66`		`- formattedQuery = FormatBlockComment(token, formattedQuery);`
	`79`	`+ FormatBlockComment(token, formattedQuery);`
`67`	`80`	`}`
`68`	`81`	`else if (token.Type == TokenTypes.RESERVED_TOP_LEVEL)`
`69`	`82`	`{`
`70`		`- formattedQuery = FormatToplevelReservedWord(token, formattedQuery);`
	`83`	`+ FormatToplevelReservedWord(token, formattedQuery);`
`71`	`84`	`_previousReservedToken = token;`
`72`	`85`	`}`
`73`	`86`	`else if (token.Type == TokenTypes.RESERVED_TOP_LEVEL_NO_INDENT)`
`74`	`87`	`{`
`75`		`- formattedQuery = FormatTopLevelReservedWordNoIndent(token, formattedQuery);`
	`88`	`+ FormatTopLevelReservedWordNoIndent(token, formattedQuery);`
`76`	`89`	`_previousReservedToken = token;`
`77`	`90`	`}`
`78`	`91`	`else if (token.Type == TokenTypes.RESERVED_NEWLINE)`
`79`	`92`	`{`
`80`		`- formattedQuery = FormatNewlineReservedWord(token, formattedQuery);`
	`93`	`+ FormatNewlineReservedWord(token, formattedQuery);`
`81`	`94`	`_previousReservedToken = token;`
`82`	`95`	`}`
`83`	`96`	`else if (token.Type == TokenTypes.RESERVED)`
`84`	`97`	`{`
`85`		`- formattedQuery = FormatWithSpaces(token, formattedQuery);`
	`98`	`+ FormatWithSpaces(token, formattedQuery);`
`86`	`99`	`_previousReservedToken = token;`
`87`	`100`	`}`
`88`	`101`	`else if (token.Type == TokenTypes.OPEN_PAREN)`
`89`	`102`	`{`
`90`		`- formattedQuery = FormatOpeningParentheses(token, formattedQuery);`
	`103`	`+ FormatOpeningParentheses(token, formattedQuery);`
`91`	`104`	`}`
`92`	`105`	`else if (token.Type == TokenTypes.CLOSE_PAREN)`
`93`	`106`	`{`
`94`		`- formattedQuery = FormatClosingParentheses(token, formattedQuery);`
	`107`	`+ FormatClosingParentheses(token, formattedQuery);`
`95`	`108`	`}`
`96`	`109`	`else if (token.Type == TokenTypes.PLACEHOLDER)`
`97`	`110`	`{`
`98`		`- formattedQuery = FormatPlaceholder(token, formattedQuery);`
	`111`	`+ FormatPlaceholder(token, formattedQuery);`
`99`	`112`	`}`
`100`	`113`	`else if (token.Value.Equals(","))`
`101`	`114`	`{`
`102`		`- formattedQuery = FormatComma(token, formattedQuery);`
	`115`	`+ FormatComma(token, formattedQuery);`
`103`	`116`	`}`
`104`	`117`	`else if (token.Value.Equals(":"))`
`105`	`118`	`{`
`106`		`- formattedQuery = FormatWithSpaceAfter(token, formattedQuery);`
	`119`	`+ FormatWithSpaceAfter(token, formattedQuery);`
`107`	`120`	`}`
`108`	`121`	`else if (token.Value.Equals("."))`
`109`	`122`	`{`
`110`		`- formattedQuery = FormatWithoutSpaces(token, formattedQuery);`
	`123`	`+ FormatWithoutSpaces(token, formattedQuery);`
`111`	`124`	`}`
`112`	`125`	`else if (token.Value.Equals(";"))`
`113`	`126`	`{`
`114`		`- formattedQuery = FormatQuerySeparator(token, formattedQuery);`
	`127`	`+ FormatQuerySeparator(token, formattedQuery);`
`115`	`128`	`}`
`116`	`129`	`else`
`117`	`130`	`{`
`118`		`- formattedQuery = FormatWithSpaces(token, formattedQuery);`
	`131`	`+ FormatWithSpaces(token, formattedQuery);`
`119`	`132`	`}`
`120`	`133`	`}`
`121`	`134`
`122`		`- return formattedQuery;`
	`135`	`+ return formattedQuery.ToString();`
`123`	`136`	`}`
`124`	`137`
`125`		`- protected virtual string FormatLineComment(Token token, string query)`
	`138`	`+ protected virtual void FormatLineComment(Token token, StringBuilder query)`
`126`	`139`	`{`
`127`		`- return AddNewline(query + Show(token));`
	`140`	`+ query.Append(Show(token));`
	`141`	`+ AddNewline(query);`
`128`	`142`	`}`
`129`	`143`
`130`		`- protected virtual string FormatBlockComment(Token token, string query)`
	`144`	`+ protected virtual void FormatBlockComment(Token token, StringBuilder query)`
`131`	`145`	`{`
`132`		`- return AddNewline(AddNewline(query) + IndentComment(token.Value));`
	`146`	`+ AddNewline(query);`
	`147`	`+ query.Append(IndentComment(token.Value));`
	`148`	`+ AddNewline(query);`
`133`	`149`	`}`
`134`	`150`
`135`	`151`	`protected virtual string IndentComment(string comment)`
`136`	`152`	`{`
`137`	`153`	`return comment.Replace("\n", "\n" + _indentation.GetIndent());`
`138`	`154`	`}`
`139`	`155`
`140`		`- protected virtual string FormatTopLevelReservedWordNoIndent(Token token, string query)`
	`156`	`+ protected virtual void FormatTopLevelReservedWordNoIndent(Token token, StringBuilder query)`
`141`	`157`	`{`
`142`	`158`	`_indentation.DecreaseTopLevel();`
`143`		`- query = AddNewline(query) + EqualizeWhitespace(Show(token));`
`144`		`- return AddNewline(query);`
	`159`	`+ AddNewline(query);`
	`160`	`+ query.Append(EqualizeWhitespace(Show(token)));`
	`161`	`+ AddNewline(query);`
`145`	`162`	`}`
`146`	`163`
`147`		`- protected virtual string FormatToplevelReservedWord(Token token, string query)`
	`164`	`+ protected virtual void FormatToplevelReservedWord(Token token, StringBuilder query)`
`148`	`165`	`{`
`149`	`166`	`_indentation.DecreaseTopLevel();`
`150`		`-`
`151`		`- query = AddNewline(query);`
`152`		`-`
	`167`	`+ AddNewline(query);`
`153`	`168`	`_indentation.IncreaseTopLevel();`
`154`	`169`
`155`		`- query += EqualizeWhitespace(Show(token));`
`156`		`- return AddNewline(query);`
	`170`	`+ query.Append(EqualizeWhitespace(Show(token)));`
	`171`	`+ AddNewline(query);`
`157`	`172`	`}`
`158`	`173`
`159`		`- protected virtual string FormatNewlineReservedWord(Token token, string query)`
	`174`	`+ protected virtual void FormatNewlineReservedWord(Token token, StringBuilder query)`
`160`	`175`	`{`
`161`	`176`	`if (Token.IsAnd(token) && Token.IsBetween(TokenLookBehind(2)))`
`162`	`177`	`{`
`163`		`- return FormatWithSpaces(token, query);`
	`178`	`+ FormatWithSpaces(token, query);`
	`179`	`+ return;`
`164`	`180`	`}`
`165`	`181`
`166`		`- return AddNewline(query) + EqualizeWhitespace(Show(token)) + " ";`
	`182`	`+ AddNewline(query);`
	`183`	`+ query.Append(EqualizeWhitespace(Show(token))).Append(" ");`
`167`	`184`	`}`
`168`	`185`
`169`	`186`	`protected static string EqualizeWhitespace(string str)`
`170`	`187`	`{`
`171`		`- return Regex.Replace(str, @"\s+", " ");`
	`188`	`+ // Uses the statically compiled regex`
	`189`	`+ return s_whitespaceRegex.Replace(str, " ");`
`172`	`190`	`}`
`173`	`191`
`174`		`- private static readonly HashSet<TokenTypes> s_preserveWhitespaceFor =`
`175`		`- new HashSet<TokenTypes> {`
`176`		`- TokenTypes.OPEN_PAREN,`
`177`		`- TokenTypes.LINE_COMMENT,`
`178`		`- TokenTypes.OPERATOR,`
`179`		`- TokenTypes.RESERVED_NEWLINE};`
`180`		`-`
`181`		`- protected virtual string FormatOpeningParentheses(Token token, string query)`
	`192`	`+ protected virtual void FormatOpeningParentheses(Token token, StringBuilder query)`
`182`	`193`	`{`
`183`	`194`	`if (string.IsNullOrEmpty(token.WhitespaceBefore)`
`184`	`195`	`&& (TokenLookBehind() == default \|\| !s_preserveWhitespaceFor.Contains(TokenLookBehind().Type)))`
`185`	`196`	`{`
`186`		`- query = query.TrimEnd();`
	`197`	`+ TrimEnd(query);`
`187`	`198`	`}`
`188`	`199`
`189`		`- query += Show(token);`
	`200`	`+ query.Append(Show(token));`
`190`	`201`
`191`	`202`	`_inlineBlock.BeginIfPossible(_tokens, _index);`
`192`	`203`
`@@ -195,65 +206,78 @@ protected virtual string FormatOpeningParentheses(Token token, string query)`
`195`	`206`	`_indentation.IncreaseBlockLevel();`
`196`	`207`	`if (!_cfg.SkipWhitespaceNearBlockParentheses)`
`197`	`208`	`{`
`198`		`- query = AddNewline(query);`
	`209`	`+ AddNewline(query);`
`199`	`210`	`}`
`200`	`211`	`}`
`201`		`-`
`202`		`- return query;`
`203`	`212`	`}`
`204`	`213`
`205`		`- protected virtual string FormatClosingParentheses(Token token, string query)`
	`214`	`+ protected virtual void FormatClosingParentheses(Token token, StringBuilder query)`
`206`	`215`	`{`
`207`	`216`	`if (_inlineBlock.IsActive())`
`208`	`217`	`{`
`209`	`218`	`_inlineBlock.End();`
`210`		`- return FormatWithSpaceAfter(token, query);`
	`219`	`+ FormatWithSpaceAfter(token, query);`
`211`	`220`	`}`
`212`	`221`	`else`
`213`	`222`	`{`
`214`	`223`	`_indentation.DecreaseBlockLevel();`
`215`	`224`
`216`	`225`	`if (!_cfg.SkipWhitespaceNearBlockParentheses)`
`217`	`226`	`{`
`218`		`- return FormatWithSpaces(token, AddNewline(query));`
	`227`	`+ AddNewline(query);`
	`228`	`+ FormatWithSpaces(token, query);`
	`229`	`+ }`
	`230`	`+ else`
	`231`	`+ {`
	`232`	`+ FormatWithoutSpaces(token, query);`
`219`	`233`	`}`
`220`		`-`
`221`		`- return FormatWithoutSpaces(token, query);`
`222`	`234`	`}`
`223`	`235`	`}`
`224`	`236`
`225`		`- protected virtual string FormatPlaceholder(Token token, string query)`
	`237`	`+ protected virtual void FormatPlaceholder(Token token, StringBuilder query)`
`226`	`238`	`{`
`227`		`- return query + _parameters.Get(token) + " ";`
	`239`	`+ query.Append(_parameters.Get(token)).Append(" ");`
`228`	`240`	`}`
`229`	`241`
`230`		`- protected virtual string FormatComma(Token token, string query)`
	`242`	`+ protected virtual void FormatComma(Token token, StringBuilder query)`
`231`	`243`	`{`
`232`		`- query = query.TrimEnd() + Show(token) + " ";`
`233`		`- return _inlineBlock.IsActive() \|\| Token.IsLimit(_previousReservedToken) ? query : AddNewline(query);`
	`244`	`+ TrimEnd(query);`
	`245`	`+ query.Append(Show(token)).Append(" ");`
	`246`	`+`
	`247`	`+ if (!_inlineBlock.IsActive() && !Token.IsLimit(_previousReservedToken))`
	`248`	`+ {`
	`249`	`+ AddNewline(query);`
	`250`	`+ }`
`234`	`251`	`}`
`235`	`252`
`236`		`- protected virtual string FormatWithSpaceAfter(Token token, string query)`
	`253`	`+ protected virtual void FormatWithSpaceAfter(Token token, StringBuilder query)`
`237`	`254`	`{`
`238`		`- return query.TrimEnd() + Show(token) + " ";`
	`255`	`+ TrimEnd(query);`
	`256`	`+ query.Append(Show(token)).Append(" ");`
`239`	`257`	`}`
`240`	`258`
`241`		`- protected virtual string FormatWithoutSpaces(Token token, string query)`
	`259`	`+ protected virtual void FormatWithoutSpaces(Token token, StringBuilder query)`
`242`	`260`	`{`
`243`		`- return query.TrimEnd() + Show(token);`
	`261`	`+ TrimEnd(query);`
	`262`	`+ query.Append(Show(token));`
`244`	`263`	`}`
`245`	`264`
`246`		`- protected virtual string FormatWithSpaces(Token token, string query)`
	`265`	`+ protected virtual void FormatWithSpaces(Token token, StringBuilder query)`
`247`	`266`	`{`
`248`		`- return query + Show(token) + " ";`
	`267`	`+ query.Append(Show(token)).Append(" ");`
`249`	`268`	`}`
`250`	`269`
`251`		`- protected virtual string FormatQuerySeparator(Token token, string query)`
	`270`	`+ protected virtual void FormatQuerySeparator(Token token, StringBuilder query)`
`252`	`271`	`{`
`253`	`272`	`_indentation.ResetIndentation();`
`254`		`- return query.TrimEnd()`
`255`		`- + Show(token)`
`256`		`- + Utils.Repeat("\n", _cfg.LinesBetweenQueries == default ? 1 : _cfg.LinesBetweenQueries);`
	`273`	`+ TrimEnd(query);`
	`274`	`+ query.Append(Show(token));`
	`275`	`+`
	`276`	`+ var lines = _cfg.LinesBetweenQueries == default ? 1 : _cfg.LinesBetweenQueries;`
	`277`	`+ for (var i = 0; i < lines; i++)`
	`278`	`+ {`
	`279`	`+ query.Append('\n');`
	`280`	`+ }`
`257`	`281`	`}`
`258`	`282`
`259`	`283`	`protected virtual string Show(Token token)`
`@@ -266,49 +290,42 @@ protected virtual string Show(Token token)`
`266`	`290`	`\|\| token.Type == TokenTypes.OPEN_PAREN`
`267`	`291`	`\|\| token.Type == TokenTypes.CLOSE_PAREN))`
`268`	`292`	`{`
	`293`	`+ // Note: If memory is still tight, caching upper-case values at the token generation stage is even better.`
`269`	`294`	`return token.Value.ToUpper();`
`270`	`295`	`}`
`271`	`296`
`272`	`297`	`return token.Value;`
`273`	`298`	`}`
`274`	`299`
`275`		`- protected virtual string AddNewline(string query)`
	`300`	`+ protected virtual void AddNewline(StringBuilder query)`
`276`	`301`	`{`
`277`		`- query = query.TrimEnd();`
`278`		`- if (!query.EndsWith("\n"))`
	`302`	`+ TrimEnd(query);`
	`303`	`+ // Replaces expensive .EndsWith("\n") with a fast char index lookup`
	`304`	`+ if (query.Length == 0 \|\| query[query.Length - 1] != '\n')`
`279`	`305`	`{`
`280`		`- query += "\n";`
	`306`	`+ query.Append('\n');`
`281`	`307`	`}`
`282`	`308`
`283`		`- return query + _indentation.GetIndent();`
`284`		`- }`
`285`		`-`
`286`		`- protected Token TokenLookBehind()`
`287`		`- {`
`288`		`- return TokenLookBehind(1);`
	`309`	`+ query.Append(_indentation.GetIndent());`
`289`	`310`	`}`
`290`	`311`
`291`		`- protected Token TokenLookBehind(int n)`
	`312`	`+ // OPTIMIZATION: Extremely fast inline trailing whitespace removal`
	`313`	`+ protected void TrimEnd(StringBuilder sb)`
`292`	`314`	`{`
`293`		`- return _tokens.Get(_index - n);`
`294`		`- }`
`295`		`-`
`296`		`- protected Token TokenLookAhead()`
`297`		`- {`
`298`		`- return TokenLookAhead(1);`
	`315`	`+ while (sb.Length > 0 && char.IsWhiteSpace(sb[sb.Length - 1]))`
	`316`	`+ {`
	`317`	`+ sb.Length--;`
	`318`	`+ }`
`299`	`319`	`}`
`300`	`320`
`301`		`- protected Token TokenLookAhead(int n)`
`302`		`- {`
`303`		`- return _tokens.Get(_index + n);`
`304`		`-`
`305`		`- }`
	`321`	`+ protected Token TokenLookBehind() => TokenLookBehind(1);`
	`322`	`+ protected Token TokenLookBehind(int n) => _tokens.Get(_index - n);`
	`323`	`+ protected Token TokenLookAhead() => TokenLookAhead(1);`
	`324`	`+ protected Token TokenLookAhead(int n) => _tokens.Get(_index + n);`
`306`	`325`
`307`	`326`	`public virtual DialectConfig DoDialectConfig()`
`308`	`327`	`{`
`309`	`328`	`return _doDialectConfigFunc.Invoke();`
`310`	`329`	`}`
`311`		`-`
`312`		`- public Func<DialectConfig> _doDialectConfigFunc;`
`313`	`330`	`}`
`314`	`331`	`}`