Merge pull request #616 from toburger/fix_parameter_placeholder

ahmad-moussawi · web-flow · commit 6337a577e330 · 2022-09-28T21:01:18.000+03:00
Fix places where the parameterPlaceholder is hardcoded to a ?
diff --git a/QueryBuilder/Compilers/Compiler.cs b/QueryBuilder/Compilers/Compiler.cs
@@ -127,7 +127,7 @@ protected virtual SqlResult CompileRaw(Query query)
                 ctx = CompileCteQuery(ctx, query);
             }
 
-            ctx.RawSql = Helper.ExpandParameters(ctx.RawSql, "?", ctx.Bindings.ToArray());
+            ctx.RawSql = Helper.ExpandParameters(ctx.RawSql, parameterPlaceholder, ctx.Bindings.ToArray());
 
             return ctx;
         }
@@ -214,7 +214,7 @@ protected virtual SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc)
         {
             var ctx = new SqlResult();
 
-            var row = "SELECT " + string.Join(", ", adHoc.Columns.Select(col => $"? AS {Wrap(col)}"));
+            var row = "SELECT " + string.Join(", ", adHoc.Columns.Select(col => $"{parameterPlaceholder} AS {Wrap(col)}"));
 
             var fromTable = SingleRowDummyTableName;
 
@@ -798,19 +798,19 @@ public virtual string CompileLimit(SqlResult ctx)
             if (offset == 0)
             {
                 ctx.Bindings.Add(limit);
-                return "LIMIT ?";
+                return $"LIMIT {parameterPlaceholder}";
             }
 
             if (limit == 0)
             {
                 ctx.Bindings.Add(offset);
-                return "OFFSET ?";
+                return $"OFFSET {parameterPlaceholder}";
             }
 
             ctx.Bindings.Add(limit);
             ctx.Bindings.Add(offset);
 
-            return "LIMIT ? OFFSET ?";
+            return $"LIMIT {parameterPlaceholder} OFFSET {parameterPlaceholder}";
         }
 
         /// <summary>
@@ -953,11 +953,11 @@ public virtual string Parameter(SqlResult ctx, object parameter)
             {
                 var value = ctx.Query.FindVariable(variable.Name);
                 ctx.Bindings.Add(value);
-                return "?";
+                return parameterPlaceholder;
             }
 
             ctx.Bindings.Add(parameter);
-            return "?";
+            return parameterPlaceholder;
         }
 
         /// <summary>
diff --git a/QueryBuilder/Compilers/FirebirdCompiler.cs b/QueryBuilder/Compilers/FirebirdCompiler.cs
@@ -39,7 +39,7 @@ public override string CompileLimit(SqlResult ctx)
                 ctx.Bindings.Add(offset + 1);
                 ctx.Bindings.Add(limit + offset);
 
-                return "ROWS ? TO ?";
+                return $"ROWS {parameterPlaceholder} TO {parameterPlaceholder}";
             }
 
             return null;
@@ -59,15 +59,15 @@ protected override string CompileColumns(SqlResult ctx)
 
                 ctx.Query.ClearComponent("limit");
 
-                return "SELECT FIRST ?" + compiled.Substring(6);
+                return $"SELECT FIRST {parameterPlaceholder}" + compiled.Substring(6);
             }
             else if (limit == 0 && offset > 0)
             {
                 ctx.Bindings.Insert(0, offset);
 
                 ctx.Query.ClearComponent("offset");
 
-                return "SELECT SKIP ?" + compiled.Substring(6);
+                return $"SELECT SKIP {parameterPlaceholder}" + compiled.Substring(6);
             }
 
             return compiled;
diff --git a/QueryBuilder/Compilers/MySqlCompiler.cs b/QueryBuilder/Compilers/MySqlCompiler.cs
@@ -24,7 +24,7 @@ public override string CompileLimit(SqlResult ctx)
             if (offset == 0)
             {
                 ctx.Bindings.Add(limit);
-                return "LIMIT ?";
+                return $"LIMIT {parameterPlaceholder}";
             }
 
             if (limit == 0)
@@ -34,15 +34,15 @@ public override string CompileLimit(SqlResult ctx)
                 // to avoid this error.
 
                 ctx.Bindings.Add(offset);
-                return "LIMIT 18446744073709551615 OFFSET ?";
+                return $"LIMIT 18446744073709551615 OFFSET {parameterPlaceholder}";
             }
 
             // We have both values
 
             ctx.Bindings.Add(limit);
             ctx.Bindings.Add(offset);
 
-            return "LIMIT ? OFFSET ?";
+            return $"LIMIT {parameterPlaceholder} OFFSET {parameterPlaceholder}";
 
         }
     }
diff --git a/QueryBuilder/Compilers/OracleCompiler.cs b/QueryBuilder/Compilers/OracleCompiler.cs
@@ -58,13 +58,13 @@ public override string CompileLimit(SqlResult ctx)
             if (limit == 0)
             {
                 ctx.Bindings.Add(offset);
-                return $"{safeOrder}OFFSET ? ROWS";
+                return $"{safeOrder}OFFSET {parameterPlaceholder} ROWS";
             }
 
             ctx.Bindings.Add(offset);
             ctx.Bindings.Add(limit);
 
-            return $"{safeOrder}OFFSET ? ROWS FETCH NEXT ? ROWS ONLY";
+            return $"{safeOrder}OFFSET {parameterPlaceholder} ROWS FETCH NEXT {parameterPlaceholder} ROWS ONLY";
         }
 
         internal void ApplyLegacyLimit(SqlResult ctx)
@@ -80,17 +80,17 @@ internal void ApplyLegacyLimit(SqlResult ctx)
             string newSql;
             if (limit == 0)
             {
-                newSql = $"SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM ({ctx.RawSql}) \"results_wrapper\") WHERE \"row_num\" > ?";
+                newSql = $"SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM ({ctx.RawSql}) \"results_wrapper\") WHERE \"row_num\" > {parameterPlaceholder}";
                 ctx.Bindings.Add(offset);
             }
             else if (offset == 0)
             {
-                newSql = $"SELECT * FROM ({ctx.RawSql}) WHERE ROWNUM <= ?";
+                newSql = $"SELECT * FROM ({ctx.RawSql}) WHERE ROWNUM <= {parameterPlaceholder}";
                 ctx.Bindings.Add(limit);
             }
             else
             {
-                newSql = $"SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM ({ctx.RawSql}) \"results_wrapper\" WHERE ROWNUM <= ?) WHERE \"row_num\" > ?";
+                newSql = $"SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM ({ctx.RawSql}) \"results_wrapper\" WHERE ROWNUM <= {parameterPlaceholder}) WHERE \"row_num\" > {parameterPlaceholder}";
                 ctx.Bindings.Add(limit + offset);
                 ctx.Bindings.Add(offset);
             }
diff --git a/QueryBuilder/Compilers/SqlServerCompiler.cs b/QueryBuilder/Compilers/SqlServerCompiler.cs
@@ -48,12 +48,12 @@ protected override SqlResult CompileSelectQuery(Query query)
 
             if (limit == 0)
             {
-                result.RawSql = $"SELECT * FROM ({result.RawSql}) AS [results_wrapper] WHERE [row_num] >= ?";
+                result.RawSql = $"SELECT * FROM ({result.RawSql}) AS [results_wrapper] WHERE [row_num] >= {parameterPlaceholder}";
                 result.Bindings.Add(offset + 1);
             }
             else
             {
-                result.RawSql = $"SELECT * FROM ({result.RawSql}) AS [results_wrapper] WHERE [row_num] BETWEEN ? AND ?";
+                result.RawSql = $"SELECT * FROM ({result.RawSql}) AS [results_wrapper] WHERE [row_num] BETWEEN {parameterPlaceholder} AND {parameterPlaceholder}";
                 result.Bindings.Add(offset + 1);
                 result.Bindings.Add(limit + offset);
             }
@@ -86,10 +86,10 @@ protected override string CompileColumns(SqlResult ctx)
                 // handle distinct
                 if (compiled.IndexOf("SELECT DISTINCT") == 0)
                 {
-                    return "SELECT DISTINCT TOP (?)" + compiled.Substring(15);
+                    return $"SELECT DISTINCT TOP ({parameterPlaceholder}){compiled.Substring(15)}";
                 }
 
-                return "SELECT TOP (?)" + compiled.Substring(6);
+                return $"SELECT TOP ({parameterPlaceholder}){compiled.Substring(6)}";
             }
 
             return compiled;
@@ -121,13 +121,13 @@ public override string CompileLimit(SqlResult ctx)
             if (limit == 0)
             {
                 ctx.Bindings.Add(offset);
-                return $"{safeOrder}OFFSET ? ROWS";
+                return $"{safeOrder}OFFSET {parameterPlaceholder} ROWS";
             }
 
             ctx.Bindings.Add(offset);
             ctx.Bindings.Add(limit);
 
-            return $"{safeOrder}OFFSET ? ROWS FETCH NEXT ? ROWS ONLY";
+            return $"{safeOrder}OFFSET {parameterPlaceholder} ROWS FETCH NEXT {parameterPlaceholder} ROWS ONLY";
         }
 
         public override string CompileRandom(string seed)
@@ -177,7 +177,7 @@ protected override SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc)
 
             var colNames = string.Join(", ", adHoc.Columns.Select(Wrap));
 
-            var valueRow = string.Join(", ", Enumerable.Repeat("?", adHoc.Columns.Count));
+            var valueRow = string.Join(", ", Enumerable.Repeat(parameterPlaceholder, adHoc.Columns.Count));
             var valueRows = string.Join(", ", Enumerable.Repeat($"({valueRow})", adHoc.Values.Count / adHoc.Columns.Count));
             var sql = $"SELECT {colNames} FROM (VALUES {valueRows}) AS tbl ({colNames})";
 
diff --git a/QueryBuilder/Compilers/SqliteCompiler.cs b/QueryBuilder/Compilers/SqliteCompiler.cs
@@ -7,8 +7,6 @@ namespace SqlKata.Compilers
     public class SqliteCompiler : Compiler
     {
         public override string EngineCode { get; } = EngineCodes.Sqlite;
-        protected override string parameterPlaceholder { get; set; } = "?";
-        protected override string parameterPrefix { get; set; } = "@p";
         protected override string OpeningIdentifier { get; set; } = "\"";
         protected override string ClosingIdentifier { get; set; } = "\"";
         protected override string LastId { get; set; } = "select last_insert_rowid() as id";
@@ -31,7 +29,7 @@ public override string CompileLimit(SqlResult ctx)
             if (limit == 0 && offset > 0)
             {
                 ctx.Bindings.Add(offset);
-                return "LIMIT -1 OFFSET ?";
+                return $"LIMIT -1 OFFSET {parameterPlaceholder}";
             }
 
             return base.CompileLimit(ctx);

Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ protected virtual SqlResult CompileRaw(Query query)`
`127`	`127`	`ctx = CompileCteQuery(ctx, query);`
`128`	`128`	`}`
`129`	`129`
`130`		`- ctx.RawSql = Helper.ExpandParameters(ctx.RawSql, "?", ctx.Bindings.ToArray());`
	`130`	`+ ctx.RawSql = Helper.ExpandParameters(ctx.RawSql, parameterPlaceholder, ctx.Bindings.ToArray());`
`131`	`131`
`132`	`132`	`return ctx;`
`133`	`133`	`}`
`@@ -214,7 +214,7 @@ protected virtual SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc)`
`214`	`214`	`{`
`215`	`215`	`var ctx = new SqlResult();`
`216`	`216`
`217`		`- var row = "SELECT " + string.Join(", ", adHoc.Columns.Select(col => $"? AS {Wrap(col)}"));`
	`217`	`+ var row = "SELECT " + string.Join(", ", adHoc.Columns.Select(col => $"{parameterPlaceholder} AS {Wrap(col)}"));`
`218`	`218`
`219`	`219`	`var fromTable = SingleRowDummyTableName;`
`220`	`220`
`@@ -798,19 +798,19 @@ public virtual string CompileLimit(SqlResult ctx)`
`798`	`798`	`if (offset == 0)`
`799`	`799`	`{`
`800`	`800`	`ctx.Bindings.Add(limit);`
`801`		`- return "LIMIT ?";`
	`801`	`+ return $"LIMIT {parameterPlaceholder}";`
`802`	`802`	`}`
`803`	`803`
`804`	`804`	`if (limit == 0)`
`805`	`805`	`{`
`806`	`806`	`ctx.Bindings.Add(offset);`
`807`		`- return "OFFSET ?";`
	`807`	`+ return $"OFFSET {parameterPlaceholder}";`
`808`	`808`	`}`
`809`	`809`
`810`	`810`	`ctx.Bindings.Add(limit);`
`811`	`811`	`ctx.Bindings.Add(offset);`
`812`	`812`
`813`		`- return "LIMIT ? OFFSET ?";`
	`813`	`+ return $"LIMIT {parameterPlaceholder} OFFSET {parameterPlaceholder}";`
`814`	`814`	`}`
`815`	`815`
`816`	`816`	`/// <summary>`
`@@ -953,11 +953,11 @@ public virtual string Parameter(SqlResult ctx, object parameter)`
`953`	`953`	`{`
`954`	`954`	`var value = ctx.Query.FindVariable(variable.Name);`
`955`	`955`	`ctx.Bindings.Add(value);`
`956`		`- return "?";`
	`956`	`+ return parameterPlaceholder;`
`957`	`957`	`}`
`958`	`958`
`959`	`959`	`ctx.Bindings.Add(parameter);`
`960`		`- return "?";`
	`960`	`+ return parameterPlaceholder;`
`961`	`961`	`}`
`962`	`962`
`963`	`963`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ public override string CompileLimit(SqlResult ctx)`
`39`	`39`	`ctx.Bindings.Add(offset + 1);`
`40`	`40`	`ctx.Bindings.Add(limit + offset);`
`41`	`41`
`42`		`- return "ROWS ? TO ?";`
	`42`	`+ return $"ROWS {parameterPlaceholder} TO {parameterPlaceholder}";`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`return null;`
`@@ -59,15 +59,15 @@ protected override string CompileColumns(SqlResult ctx)`
`59`	`59`
`60`	`60`	`ctx.Query.ClearComponent("limit");`
`61`	`61`
`62`		`- return "SELECT FIRST ?" + compiled.Substring(6);`
	`62`	`+ return $"SELECT FIRST {parameterPlaceholder}" + compiled.Substring(6);`
`63`	`63`	`}`
`64`	`64`	`else if (limit == 0 && offset > 0)`
`65`	`65`	`{`
`66`	`66`	`ctx.Bindings.Insert(0, offset);`
`67`	`67`
`68`	`68`	`ctx.Query.ClearComponent("offset");`
`69`	`69`
`70`		`- return "SELECT SKIP ?" + compiled.Substring(6);`
	`70`	`+ return $"SELECT SKIP {parameterPlaceholder}" + compiled.Substring(6);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`return compiled;`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public override string CompileLimit(SqlResult ctx)`
`24`	`24`	`if (offset == 0)`
`25`	`25`	`{`
`26`	`26`	`ctx.Bindings.Add(limit);`
`27`		`- return "LIMIT ?";`
	`27`	`+ return $"LIMIT {parameterPlaceholder}";`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`if (limit == 0)`
`@@ -34,15 +34,15 @@ public override string CompileLimit(SqlResult ctx)`
`34`	`34`	`// to avoid this error.`
`35`	`35`
`36`	`36`	`ctx.Bindings.Add(offset);`
`37`		`- return "LIMIT 18446744073709551615 OFFSET ?";`
	`37`	`+ return $"LIMIT 18446744073709551615 OFFSET {parameterPlaceholder}";`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`// We have both values`
`41`	`41`
`42`	`42`	`ctx.Bindings.Add(limit);`
`43`	`43`	`ctx.Bindings.Add(offset);`
`44`	`44`
`45`		`- return "LIMIT ? OFFSET ?";`
	`45`	`+ return $"LIMIT {parameterPlaceholder} OFFSET {parameterPlaceholder}";`
`46`	`46`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,13 +58,13 @@ public override string CompileLimit(SqlResult ctx)`
`58`	`58`	`if (limit == 0)`
`59`	`59`	`{`
`60`	`60`	`ctx.Bindings.Add(offset);`
`61`		`- return $"{safeOrder}OFFSET ? ROWS";`
	`61`	`+ return $"{safeOrder}OFFSET {parameterPlaceholder} ROWS";`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`ctx.Bindings.Add(offset);`
`65`	`65`	`ctx.Bindings.Add(limit);`
`66`	`66`
`67`		`- return $"{safeOrder}OFFSET ? ROWS FETCH NEXT ? ROWS ONLY";`
	`67`	`+ return $"{safeOrder}OFFSET {parameterPlaceholder} ROWS FETCH NEXT {parameterPlaceholder} ROWS ONLY";`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`internal void ApplyLegacyLimit(SqlResult ctx)`
`@@ -80,17 +80,17 @@ internal void ApplyLegacyLimit(SqlResult ctx)`
`80`	`80`	`string newSql;`
`81`	`81`	`if (limit == 0)`
`82`	`82`	`{`
`83`		`- newSql = $"SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM ({ctx.RawSql}) \"results_wrapper\") WHERE \"row_num\" > ?";`
	`83`	`+ newSql = $"SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM ({ctx.RawSql}) \"results_wrapper\") WHERE \"row_num\" > {parameterPlaceholder}";`
`84`	`84`	`ctx.Bindings.Add(offset);`
`85`	`85`	`}`
`86`	`86`	`else if (offset == 0)`
`87`	`87`	`{`
`88`		`- newSql = $"SELECT * FROM ({ctx.RawSql}) WHERE ROWNUM <= ?";`
	`88`	`+ newSql = $"SELECT * FROM ({ctx.RawSql}) WHERE ROWNUM <= {parameterPlaceholder}";`
`89`	`89`	`ctx.Bindings.Add(limit);`
`90`	`90`	`}`
`91`	`91`	`else`
`92`	`92`	`{`
`93`		`- newSql = $"SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM ({ctx.RawSql}) \"results_wrapper\" WHERE ROWNUM <= ?) WHERE \"row_num\" > ?";`
	`93`	`+ newSql = $"SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM ({ctx.RawSql}) \"results_wrapper\" WHERE ROWNUM <= {parameterPlaceholder}) WHERE \"row_num\" > {parameterPlaceholder}";`
`94`	`94`	`ctx.Bindings.Add(limit + offset);`
`95`	`95`	`ctx.Bindings.Add(offset);`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,12 +48,12 @@ protected override SqlResult CompileSelectQuery(Query query)`
`48`	`48`
`49`	`49`	`if (limit == 0)`
`50`	`50`	`{`
`51`		`- result.RawSql = $"SELECT * FROM ({result.RawSql}) AS [results_wrapper] WHERE [row_num] >= ?";`
	`51`	`+ result.RawSql = $"SELECT * FROM ({result.RawSql}) AS [results_wrapper] WHERE [row_num] >= {parameterPlaceholder}";`
`52`	`52`	`result.Bindings.Add(offset + 1);`
`53`	`53`	`}`
`54`	`54`	`else`
`55`	`55`	`{`
`56`		`- result.RawSql = $"SELECT * FROM ({result.RawSql}) AS [results_wrapper] WHERE [row_num] BETWEEN ? AND ?";`
	`56`	`+ result.RawSql = $"SELECT * FROM ({result.RawSql}) AS [results_wrapper] WHERE [row_num] BETWEEN {parameterPlaceholder} AND {parameterPlaceholder}";`
`57`	`57`	`result.Bindings.Add(offset + 1);`
`58`	`58`	`result.Bindings.Add(limit + offset);`
`59`	`59`	`}`
`@@ -86,10 +86,10 @@ protected override string CompileColumns(SqlResult ctx)`
`86`	`86`	`// handle distinct`
`87`	`87`	`if (compiled.IndexOf("SELECT DISTINCT") == 0)`
`88`	`88`	`{`
`89`		`- return "SELECT DISTINCT TOP (?)" + compiled.Substring(15);`
	`89`	`+ return $"SELECT DISTINCT TOP ({parameterPlaceholder}){compiled.Substring(15)}";`
`90`	`90`	`}`
`91`	`91`
`92`		`- return "SELECT TOP (?)" + compiled.Substring(6);`
	`92`	`+ return $"SELECT TOP ({parameterPlaceholder}){compiled.Substring(6)}";`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`return compiled;`
`@@ -121,13 +121,13 @@ public override string CompileLimit(SqlResult ctx)`
`121`	`121`	`if (limit == 0)`
`122`	`122`	`{`
`123`	`123`	`ctx.Bindings.Add(offset);`
`124`		`- return $"{safeOrder}OFFSET ? ROWS";`
	`124`	`+ return $"{safeOrder}OFFSET {parameterPlaceholder} ROWS";`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`ctx.Bindings.Add(offset);`
`128`	`128`	`ctx.Bindings.Add(limit);`
`129`	`129`
`130`		`- return $"{safeOrder}OFFSET ? ROWS FETCH NEXT ? ROWS ONLY";`
	`130`	`+ return $"{safeOrder}OFFSET {parameterPlaceholder} ROWS FETCH NEXT {parameterPlaceholder} ROWS ONLY";`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`public override string CompileRandom(string seed)`
`@@ -177,7 +177,7 @@ protected override SqlResult CompileAdHocQuery(AdHocTableFromClause adHoc)`
`177`	`177`
`178`	`178`	`var colNames = string.Join(", ", adHoc.Columns.Select(Wrap));`
`179`	`179`
`180`		`- var valueRow = string.Join(", ", Enumerable.Repeat("?", adHoc.Columns.Count));`
	`180`	`+ var valueRow = string.Join(", ", Enumerable.Repeat(parameterPlaceholder, adHoc.Columns.Count));`
`181`	`181`	`var valueRows = string.Join(", ", Enumerable.Repeat($"({valueRow})", adHoc.Values.Count / adHoc.Columns.Count));`
`182`	`182`	`var sql = $"SELECT {colNames} FROM (VALUES {valueRows}) AS tbl ({colNames})";`
`183`	`183`
Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,6 @@ namespace SqlKata.Compilers`
`7`	`7`	`public class SqliteCompiler : Compiler`
`8`	`8`	`{`
`9`	`9`	`public override string EngineCode { get; } = EngineCodes.Sqlite;`
`10`		`- protected override string parameterPlaceholder { get; set; } = "?";`
`11`		`- protected override string parameterPrefix { get; set; } = "@p";`
`12`	`10`	`protected override string OpeningIdentifier { get; set; } = "\"";`
`13`	`11`	`protected override string ClosingIdentifier { get; set; } = "\"";`
`14`	`12`	`protected override string LastId { get; set; } = "select last_insert_rowid() as id";`
`@@ -31,7 +29,7 @@ public override string CompileLimit(SqlResult ctx)`
`31`	`29`	`if (limit == 0 && offset > 0)`
`32`	`30`	`{`
`33`	`31`	`ctx.Bindings.Add(offset);`
`34`		`- return "LIMIT -1 OFFSET ?";`
	`32`	`+ return $"LIMIT -1 OFFSET {parameterPlaceholder}";`
`35`	`33`	`}`
`36`	`34`
`37`	`35`	`return base.CompileLimit(ctx);`