Merge branch 'master' of github.com:sqlkata/querybuilder

ahmad-moussawi · ahmad-moussawi · commit a5f67e2519e8 · 2019-04-03T14:38:59.000+03:00
diff --git a/QueryBuilder.Tests/GeneralTests.cs b/QueryBuilder.Tests/GeneralTests.cs
@@ -123,6 +123,16 @@ public void Raw_WrapIdentifiers()
             Assert.Equal("SELECT \"Id\", \"Name\", \"Age\" FROM \"Users\"", c[EngineCodes.PostgreSql]);
             Assert.Equal("SELECT \"Id\", \"Name\", \"Age\" FROM \"USERS\"", c[EngineCodes.Firebird]);
         }
+        
+        [Fact]
+        public void Raw_WrapIdentifiers_Escaped()
+        {
+            var query = new Query("Users").SelectRaw("'\\{1,2,3\\}'::int\\[\\]");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT '{1,2,3}'::int[] FROM \"Users\"", c[EngineCodes.PostgreSql]);
+        }
 
         [Fact]
         public void WrapWithSpace()
diff --git a/QueryBuilder.Tests/HelperTests.cs b/QueryBuilder.Tests/HelperTests.cs
@@ -224,5 +224,14 @@ public void ExpandParameters()
 
             Assert.Equal("where id = ? or id in (?,?) or id in ()", expanded);
         }
+
+        [Theory]
+        [InlineData(@"\{ text {", @"\", "{", "[", "{ text [")]
+        [InlineData(@"{ text {", @"\", "{", "[", "[ text [")]
+        public void WrapIdentifiers(string input, string escapeCharacter, string identifier, string newIdentifier, string expected)
+        {
+            var result = input.ReplaceIdentifierUnlessEscaped(escapeCharacter, identifier, newIdentifier);
+            Assert.Equal(expected, result);
+        }
     }
 }
diff --git a/QueryBuilder.Tests/InsertTests.cs b/QueryBuilder.Tests/InsertTests.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Linq;
 using SqlKata.Compilers;
 using SqlKata.Tests.Infrastructure;
 using Xunit;
@@ -113,5 +114,25 @@ public void InsertWithEmptyString()
                 "INSERT INTO \"BOOKS\" (\"ID\", \"AUTHOR\", \"ISBN\", \"DESCRIPTION\") VALUES (1, 'Author 1', '123456', '')",
                 c[EngineCodes.Firebird]);
         }
+
+        [Fact]
+        public void InsertWithByteArray()
+        {
+            var fauxImagebytes = new byte[] {0x1, 0x3, 0x3, 0x7};
+            var query = new Query("Books")
+                .AsInsert(new[]{"Id", "CoverImageBytes"},
+                    new object[]
+                    {
+                        1,
+                        fauxImagebytes
+                    });
+
+            var c = Compilers.Compile(query);
+            Assert.All(c.Values, a => Assert.Equal(2, a.NamedBindings.Count));
+
+            var exemplar = c[EngineCodes.SqlServer];
+            Assert.Equal("INSERT INTO [Books] ([Id], [CoverImageBytes]) VALUES (?, ?)", exemplar.RawSql);
+            Assert.Equal("INSERT INTO [Books] ([Id], [CoverImageBytes]) VALUES (@p0, @p1)", exemplar.Sql);
+        }
     }
 }
diff --git a/QueryBuilder.Tests/SelectTests.cs b/QueryBuilder.Tests/SelectTests.cs
@@ -619,5 +619,15 @@ public void JoinTypes(string given, string output)
                 $"SELECT * FROM \"USERS\" \n{output} \"COUNTRIES\" ON \"COUNTRIES\".\"ID\" = \"USERS\".\"COUNTRY_ID\"",
                 c[EngineCodes.Firebird]);
         }
+        
+        [Fact]
+        public void OrWhereRawEscaped()
+        {
+            var query = new Query("Table").WhereRaw("[MyCol] = ANY(?::int\\[\\])", "{1,2,3}");
+
+            var c = Compile(query);
+
+            Assert.Equal("SELECT * FROM \"Table\" WHERE \"MyCol\" = ANY('{1,2,3}'::int[])", c[EngineCodes.PostgreSql]);
+        }
     }
 }
diff --git a/QueryBuilder/Compilers/Compiler.Conditions.cs b/QueryBuilder/Compilers/Compiler.Conditions.cs
@@ -134,7 +134,7 @@ protected virtual string CompileBasicDateCondition(SqlResult ctx, BasicDateCondi
         {
             var column = Wrap(x.Column);
 
-            var sql = $"{x.Part.ToUpper()}({column}) {checkOperator(x.Operator)} {Parameter(ctx, x.Value)}";
+            var sql = $"{x.Part.ToUpperInvariant()}({column}) {checkOperator(x.Operator)} {Parameter(ctx, x.Value)}";
 
             return x.IsNot
                 ? $"NOT ({sql})"
diff --git a/QueryBuilder/Compilers/Compiler.cs b/QueryBuilder/Compilers/Compiler.cs
@@ -15,6 +15,7 @@ public partial class Compiler
         protected virtual string ColumnAsKeyword { get; set; } = "AS ";
         protected virtual string TableAsKeyword { get; set; } = "AS ";
         protected virtual string LastId { get; set; } = "";
+        protected virtual string EscapeCharacter { get; set; } = "\\";
 
         protected Compiler()
         {
@@ -446,7 +447,7 @@ protected virtual string CompileColumns(SqlResult ctx)
                         sql = "DISTINCT " + sql;
                     }
 
-                    return "SELECT " + aggregate.Type.ToUpper() + "(" + sql + $") {ColumnAsKeyword}" + WrapValue(aggregate.Type);
+                    return "SELECT " + aggregate.Type.ToUpperInvariant() + "(" + sql + $") {ColumnAsKeyword}" + WrapValue(aggregate.Type);
                 }
 
                 return "SELECT 1";
@@ -482,7 +483,7 @@ public virtual string CompileUnion(SqlResult ctx)
             {
                 if (clause is Combine combineClause)
                 {
-                    var combineOperator = combineClause.Operation.ToUpper() + " " + (combineClause.All ? "ALL " : "");
+                    var combineOperator = combineClause.Operation.ToUpperInvariant() + " " + (combineClause.All ? "ALL " : "");
 
                     var subCtx = CompileSelectQuery(combineClause.Query);
 
@@ -809,12 +810,11 @@ public virtual string WrapIdentifiers(string input)
             return input
 
                 // deprecated
-                .Replace("{", this.OpeningIdentifier)
-                .Replace("}", this.ClosingIdentifier)
+                .ReplaceIdentifierUnlessEscaped(this.EscapeCharacter,"{", this.OpeningIdentifier)
+                .ReplaceIdentifierUnlessEscaped(this.EscapeCharacter,"}", this.ClosingIdentifier)
 
-                .Replace("[", this.OpeningIdentifier)
-                .Replace("]", this.ClosingIdentifier);
+                .ReplaceIdentifierUnlessEscaped(this.EscapeCharacter,"[", this.OpeningIdentifier)
+                .ReplaceIdentifierUnlessEscaped(this.EscapeCharacter,"]", this.ClosingIdentifier);
         }
-
     }
 }
diff --git a/QueryBuilder/Compilers/FirebirdCompiler.cs b/QueryBuilder/Compilers/FirebirdCompiler.cs
@@ -60,7 +60,7 @@ public override string CompileUnion(SqlResult ctx)
             {
                 if (clause is Combine combineClause)
                 {
-                    var combineOperator = combineClause.Operation.ToUpper() + " " + (combineClause.All ? "ALL " : "");
+                    var combineOperator = combineClause.Operation.ToUpperInvariant() + " " + (combineClause.All ? "ALL " : "");
 
                     var subCtx = CompileSelectQuery(combineClause.Query);
 
@@ -125,7 +125,7 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond
             }
             else
             {
-                left = $"EXTRACT({condition.Part.ToUpper()} FROM {column})";
+                left = $"EXTRACT({condition.Part.ToUpperInvariant()} FROM {column})";
             }
 
             var sql = $"{left} {condition.Operator} {Parameter(ctx, condition.Value)}";
@@ -140,7 +140,7 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond
 
         public override string WrapValue(string value)
         {
-            return base.WrapValue(value).ToUpper();
+            return base.WrapValue(value).ToUpperInvariant();
         }
 
         public override string CompileTrue()
diff --git a/QueryBuilder/Compilers/PostgresCompiler.cs b/QueryBuilder/Compilers/PostgresCompiler.cs
@@ -4,7 +4,7 @@ public class PostgresCompiler : Compiler
     {
         public PostgresCompiler()
         {
-            LastId = "SELECT lastval()";
+            LastId = "SELECT lastval() AS id";
         }
 
         public override string EngineCode { get; } = EngineCodes.PostgreSql;
@@ -25,7 +25,7 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond
             }
             else
             {
-                left = $"DATE_PART('{condition.Part.ToUpper()}', {column})";
+                left = $"DATE_PART('{condition.Part.ToUpperInvariant()}', {column})";
             }
 
             var sql = $"{left} {condition.Operator} {Parameter(ctx, condition.Value)}";
@@ -38,4 +38,4 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond
             return sql;
         }
     }
-}
+}
diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs
@@ -146,17 +146,17 @@ public override string CompileFalse()
         protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCondition condition)
         {
             var column = Wrap(condition.Column);
-            var part = condition.Part.ToUpper();
+            var part = condition.Part.ToUpperInvariant();
 
             string left;
 
             if (part == "TIME" || part == "DATE")
             {
-                left = $"CAST({column} AS {part.ToUpper()})";
+                left = $"CAST({column} AS {part.ToUpperInvariant()})";
             }
             else
             {
-                left = $"DATEPART({part.ToUpper()}, {column})";
+                left = $"DATEPART({part.ToUpperInvariant()}, {column})";
             }
 
             var sql = $"{left} {condition.Operator} {Parameter(ctx, condition.Value)}";
diff --git a/QueryBuilder/Helper.cs b/QueryBuilder/Helper.cs
@@ -2,7 +2,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using System.Text.RegularExpressions;
 
 namespace SqlKata
@@ -11,7 +10,12 @@ public static class Helper
     {
         public static bool IsArray(object value)
         {
-            if (value is string)
+            if(value is string)
+            {
+                return false;
+            }
+
+            if (value is byte[])
             {
                 return false;
             }
@@ -154,5 +158,16 @@ public static IEnumerable<string> Repeat(this string str, int count)
         {
             return Enumerable.Repeat(str, count);
         }
+        
+        public static string ReplaceIdentifierUnlessEscaped(this string input, string escapeCharacter, string identifier, string newIdentifier)
+        {
+            //Replace standard, non-escaped identifiers first
+            var nonEscapedRegex = new Regex($@"(?<!{Regex.Escape(escapeCharacter)}){Regex.Escape(identifier)}");
+            var nonEscapedReplace = nonEscapedRegex.Replace(input, newIdentifier);
+            
+            //Then replace escaped identifiers, by just removing the escape character
+            var escapedRegex = new Regex($@"{Regex.Escape(escapeCharacter)}{Regex.Escape(identifier)}");
+            return escapedRegex.Replace(nonEscapedReplace, identifier);
+        }
     }
 }
diff --git a/QueryBuilder/Join.cs b/QueryBuilder/Join.cs
@@ -14,7 +14,7 @@ public string Type
             }
             set
             {
-                _type = value.ToUpper();
+                _type = value.ToUpperInvariant();
             }
         }
 
diff --git a/build.ps1 b/build.ps1
@@ -31,6 +31,7 @@ param(
 $ErrorActionPreference = "Stop"
 $msgColor = @{Default="White"; Heading="Cyan"; Danger="Red"; Success="Green"; Attention="Yellow"}
 $BuildConfiguration = 'Release'
+$DefaultCIBuildSuffix = 'ci'
 
 function Die ($message) {
     Write-Host ">>> ERROR:`t$message`n" -ForegroundColor $msgColor.Danger
@@ -90,7 +91,6 @@ if($DebugBuild)
 if($BuildNumber -eq 0 -and $PullRequestNumber -eq 0) { Die "Build Number or Pull Request Number must be supplied" }
 if(!(Test-Path "version.props")) { Die "Unable to locate required file: version.props" }
 $outputPath = "$PSScriptRoot\.nupkgs"
-$queryBuilderPath = "$PSScriptRoot\QueryBuilder\QueryBuilder.csproj"
 $stdSwitches = " /p:Configuration=$BuildConfiguration /nologo /verbosity:d /p:BuildNumber=$BuildNumber"
 
 if($SourceLinkEnable)
@@ -99,6 +99,16 @@ if($SourceLinkEnable)
 }
 
 $versionProps = [xml](Get-Content "version.props")
+
+if(-not $Env:APPVEYOR_REPRO_TAG)
+{
+    if([string]::IsNullOrWhiteSpace($versionProps.Project.PropertyGroup.VersionSuffix))
+    {
+        $versionProps.Project.PropertyGroup.VersionSuffix=$DefaultCIBuildSuffix
+        $versionProps.Save("$PSScriptRoot\version.props")
+    }
+}
+
 $versionPrefix = $versionProps.Project.PropertyGroup.VersionPrefix
 $versionSuffix = $versionProps.Project.PropertyGroup.VersionSuffix
 
diff --git a/version.props b/version.props
@@ -1,6 +1,6 @@
 <Project>
-    <PropertyGroup>
-        <VersionPrefix>1.1.7</VersionPrefix>
-        <VersionSuffix></VersionSuffix>
-    </PropertyGroup>
-</Project>
+  <PropertyGroup>
+    <VersionPrefix>1.1.8</VersionPrefix>
+    <VersionSuffix></VersionSuffix>
+  </PropertyGroup>
+</Project>

Original file line number	Diff line number	Diff line change
`@@ -224,5 +224,14 @@ public void ExpandParameters()`
`224`	`224`
`225`	`225`	`Assert.Equal("where id = ? or id in (?,?) or id in ()", expanded);`
`226`	`226`	`}`
	`227`	`+`
	`228`	`+ [Theory]`
	`229`	`+ [InlineData(@"\{ text {", @"\", "{", "[", "{ text [")]`
	`230`	`+ [InlineData(@"{ text {", @"\", "{", "[", "[ text [")]`
	`231`	`+ public void WrapIdentifiers(string input, string escapeCharacter, string identifier, string newIdentifier, string expected)`
	`232`	`+ {`
	`233`	`+ var result = input.ReplaceIdentifierUnlessEscaped(escapeCharacter, identifier, newIdentifier);`
	`234`	`+ Assert.Equal(expected, result);`
	`235`	`+ }`
`227`	`236`	`}`
`228`	`237`	`}`
Original file line number	Diff line number	Diff line change
`@@ -619,5 +619,15 @@ public void JoinTypes(string given, string output)`
`619`	`619`	`$"SELECT * FROM \"USERS\" \n{output} \"COUNTRIES\" ON \"COUNTRIES\".\"ID\" = \"USERS\".\"COUNTRY_ID\"",`
`620`	`620`	`c[EngineCodes.Firebird]);`
`621`	`621`	`}`
	`622`	`+`
	`623`	`+ [Fact]`
	`624`	`+ public void OrWhereRawEscaped()`
	`625`	`+ {`
	`626`	`+ var query = new Query("Table").WhereRaw("[MyCol] = ANY(?::int\\[\\])", "{1,2,3}");`
	`627`	`+`
	`628`	`+ var c = Compile(query);`
	`629`	`+`
	`630`	`+ Assert.Equal("SELECT * FROM \"Table\" WHERE \"MyCol\" = ANY('{1,2,3}'::int[])", c[EngineCodes.PostgreSql]);`
	`631`	`+ }`
`622`	`632`	`}`
`623`	`633`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,7 @@ protected virtual string CompileBasicDateCondition(SqlResult ctx, BasicDateCondi`
`134`	`134`	`{`
`135`	`135`	`var column = Wrap(x.Column);`
`136`	`136`
`137`		`- var sql = $"{x.Part.ToUpper()}({column}) {checkOperator(x.Operator)} {Parameter(ctx, x.Value)}";`
	`137`	`+ var sql = $"{x.Part.ToUpperInvariant()}({column}) {checkOperator(x.Operator)} {Parameter(ctx, x.Value)}";`
`138`	`138`
`139`	`139`	`return x.IsNot`
`140`	`140`	`? $"NOT ({sql})"`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ public partial class Compiler`
`15`	`15`	`protected virtual string ColumnAsKeyword { get; set; } = "AS ";`
`16`	`16`	`protected virtual string TableAsKeyword { get; set; } = "AS ";`
`17`	`17`	`protected virtual string LastId { get; set; } = "";`
	`18`	`+ protected virtual string EscapeCharacter { get; set; } = "\\";`
`18`	`19`
`19`	`20`	`protected Compiler()`
`20`	`21`	`{`
`@@ -446,7 +447,7 @@ protected virtual string CompileColumns(SqlResult ctx)`
`446`	`447`	`sql = "DISTINCT " + sql;`
`447`	`448`	`}`
`448`	`449`
`449`		`- return "SELECT " + aggregate.Type.ToUpper() + "(" + sql + $") {ColumnAsKeyword}" + WrapValue(aggregate.Type);`
	`450`	`+ return "SELECT " + aggregate.Type.ToUpperInvariant() + "(" + sql + $") {ColumnAsKeyword}" + WrapValue(aggregate.Type);`
`450`	`451`	`}`
`451`	`452`
`452`	`453`	`return "SELECT 1";`
`@@ -482,7 +483,7 @@ public virtual string CompileUnion(SqlResult ctx)`
`482`	`483`	`{`
`483`	`484`	`if (clause is Combine combineClause)`
`484`	`485`	`{`
`485`		`- var combineOperator = combineClause.Operation.ToUpper() + " " + (combineClause.All ? "ALL " : "");`
	`486`	`+ var combineOperator = combineClause.Operation.ToUpperInvariant() + " " + (combineClause.All ? "ALL " : "");`
`486`	`487`
`487`	`488`	`var subCtx = CompileSelectQuery(combineClause.Query);`
`488`	`489`
`@@ -809,12 +810,11 @@ public virtual string WrapIdentifiers(string input)`
`809`	`810`	`return input`
`810`	`811`
`811`	`812`	`// deprecated`
`812`		`- .Replace("{", this.OpeningIdentifier)`
`813`		`- .Replace("}", this.ClosingIdentifier)`
	`813`	`+ .ReplaceIdentifierUnlessEscaped(this.EscapeCharacter,"{", this.OpeningIdentifier)`
	`814`	`+ .ReplaceIdentifierUnlessEscaped(this.EscapeCharacter,"}", this.ClosingIdentifier)`
`814`	`815`
`815`		`- .Replace("[", this.OpeningIdentifier)`
`816`		`- .Replace("]", this.ClosingIdentifier);`
	`816`	`+ .ReplaceIdentifierUnlessEscaped(this.EscapeCharacter,"[", this.OpeningIdentifier)`
	`817`	`+ .ReplaceIdentifierUnlessEscaped(this.EscapeCharacter,"]", this.ClosingIdentifier);`
`817`	`818`	`}`
`818`		`-`
`819`	`819`	`}`
`820`	`820`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ public override string CompileUnion(SqlResult ctx)`
`60`	`60`	`{`
`61`	`61`	`if (clause is Combine combineClause)`
`62`	`62`	`{`
`63`		`- var combineOperator = combineClause.Operation.ToUpper() + " " + (combineClause.All ? "ALL " : "");`
	`63`	`+ var combineOperator = combineClause.Operation.ToUpperInvariant() + " " + (combineClause.All ? "ALL " : "");`
`64`	`64`
`65`	`65`	`var subCtx = CompileSelectQuery(combineClause.Query);`
`66`	`66`
`@@ -125,7 +125,7 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond`
`125`	`125`	`}`
`126`	`126`	`else`
`127`	`127`	`{`
`128`		`- left = $"EXTRACT({condition.Part.ToUpper()} FROM {column})";`
	`128`	`+ left = $"EXTRACT({condition.Part.ToUpperInvariant()} FROM {column})";`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`var sql = $"{left} {condition.Operator} {Parameter(ctx, condition.Value)}";`
`@@ -140,7 +140,7 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond`
`140`	`140`
`141`	`141`	`public override string WrapValue(string value)`
`142`	`142`	`{`
`143`		`- return base.WrapValue(value).ToUpper();`
	`143`	`+ return base.WrapValue(value).ToUpperInvariant();`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`public override string CompileTrue()`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ public class PostgresCompiler : Compiler`
`4`	`4`	`{`
`5`	`5`	`public PostgresCompiler()`
`6`	`6`	`{`
`7`		`- LastId = "SELECT lastval()";`
	`7`	`+ LastId = "SELECT lastval() AS id";`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`public override string EngineCode { get; } = EngineCodes.PostgreSql;`
`@@ -25,7 +25,7 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond`
`25`	`25`	`}`
`26`	`26`	`else`
`27`	`27`	`{`
`28`		`- left = $"DATE_PART('{condition.Part.ToUpper()}', {column})";`
	`28`	`+ left = $"DATE_PART('{condition.Part.ToUpperInvariant()}', {column})";`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`var sql = $"{left} {condition.Operator} {Parameter(ctx, condition.Value)}";`
`@@ -38,4 +38,4 @@ protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCond`
`38`	`38`	`return sql;`
`39`	`39`	`}`
`40`	`40`	`}`
`41`		`-}`
	`41`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -146,17 +146,17 @@ public override string CompileFalse()`
`146`	`146`	`protected override string CompileBasicDateCondition(SqlResult ctx, BasicDateCondition condition)`
`147`	`147`	`{`
`148`	`148`	`var column = Wrap(condition.Column);`
`149`		`- var part = condition.Part.ToUpper();`
	`149`	`+ var part = condition.Part.ToUpperInvariant();`
`150`	`150`
`151`	`151`	`string left;`
`152`	`152`
`153`	`153`	`if (part == "TIME" \|\| part == "DATE")`
`154`	`154`	`{`
`155`		`- left = $"CAST({column} AS {part.ToUpper()})";`
	`155`	`+ left = $"CAST({column} AS {part.ToUpperInvariant()})";`
`156`	`156`	`}`
`157`	`157`	`else`
`158`	`158`	`{`
`159`		`- left = $"DATEPART({part.ToUpper()}, {column})";`
	`159`	`+ left = $"DATEPART({part.ToUpperInvariant()}, {column})";`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`var sql = $"{left} {condition.Operator} {Parameter(ctx, condition.Value)}";`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`	`using System.Collections;`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using System.Linq;`
`5`		`-using System.Reflection;`
`6`	`5`	`using System.Text.RegularExpressions;`
`7`	`6`
`8`	`7`	`namespace SqlKata`
`@@ -11,7 +10,12 @@ public static class Helper`
`11`	`10`	`{`
`12`	`11`	`public static bool IsArray(object value)`
`13`	`12`	`{`
`14`		`- if (value is string)`
	`13`	`+ if(value is string)`
	`14`	`+ {`
	`15`	`+ return false;`
	`16`	`+ }`
	`17`	`+`
	`18`	`+ if (value is byte[])`
`15`	`19`	`{`
`16`	`20`	`return false;`
`17`	`21`	`}`
`@@ -154,5 +158,16 @@ public static IEnumerable<string> Repeat(this string str, int count)`
`154`	`158`	`{`
`155`	`159`	`return Enumerable.Repeat(str, count);`
`156`	`160`	`}`
	`161`	`+`
	`162`	`+ public static string ReplaceIdentifierUnlessEscaped(this string input, string escapeCharacter, string identifier, string newIdentifier)`
	`163`	`+ {`
	`164`	`+ //Replace standard, non-escaped identifiers first`
	`165`	`+ var nonEscapedRegex = new Regex($@"(?<!{Regex.Escape(escapeCharacter)}){Regex.Escape(identifier)}");`
	`166`	`+ var nonEscapedReplace = nonEscapedRegex.Replace(input, newIdentifier);`
	`167`	`+`
	`168`	`+ //Then replace escaped identifiers, by just removing the escape character`
	`169`	`+ var escapedRegex = new Regex($@"{Regex.Escape(escapeCharacter)}{Regex.Escape(identifier)}");`
	`170`	`+ return escapedRegex.Replace(nonEscapedReplace, identifier);`
	`171`	`+ }`
`157`	`172`	`}`
`158`	`173`	`}`