iss-532: Offset is now long instead of int

ahmad-moussawi · ahmad-moussawi · commit 746702aadc84 · 2022-09-10T20:40:42.000+03:00
diff --git a/QueryBuilder.Tests/Firebird/FirebirdLimitTests.cs b/QueryBuilder.Tests/Firebird/FirebirdLimitTests.cs
@@ -47,8 +47,8 @@ public void LimitAndOffset()
             var ctx = new SqlResult { Query = query };
 
             Assert.Equal("ROWS ? TO ?", compiler.CompileLimit(ctx));
-            Assert.Equal(21, ctx.Bindings[0]);
-            Assert.Equal(25, ctx.Bindings[1]);
+            Assert.Equal(21L, ctx.Bindings[0]);
+            Assert.Equal(25L, ctx.Bindings[1]);
             Assert.Equal(2, ctx.Bindings.Count);
         }
     }
diff --git a/QueryBuilder.Tests/MySql/MySqlLimitTests.cs b/QueryBuilder.Tests/MySql/MySqlLimitTests.cs
@@ -39,7 +39,7 @@ public void WithNoLimit()
             var ctx = new SqlResult { Query = query };
 
             Assert.Equal("LIMIT 18446744073709551615 OFFSET ?", compiler.CompileLimit(ctx));
-            Assert.Equal(20, ctx.Bindings[0]);
+            Assert.Equal(20L, ctx.Bindings[0]);
             Assert.Single(ctx.Bindings);
         }
 
@@ -51,7 +51,7 @@ public void WithLimitAndOffset()
 
             Assert.Equal("LIMIT ? OFFSET ?", compiler.CompileLimit(ctx));
             Assert.Equal(5, ctx.Bindings[0]);
-            Assert.Equal(20, ctx.Bindings[1]);
+            Assert.Equal(20L, ctx.Bindings[1]);
             Assert.Equal(2, ctx.Bindings.Count);
         }
     }
diff --git a/QueryBuilder.Tests/Oracle/OracleLegacyLimitTests.cs b/QueryBuilder.Tests/Oracle/OracleLegacyLimitTests.cs
@@ -58,7 +58,7 @@ public void WithNoLimit()
 
             // Assert:
             Assert.Equal("SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM (GENERATED_SQL) \"results_wrapper\") WHERE \"row_num\" > ?", ctx.RawSql);
-            Assert.Equal(20, ctx.Bindings[0]);
+            Assert.Equal(20L, ctx.Bindings[0]);
             Assert.Single(ctx.Bindings);
         }
 
@@ -74,8 +74,8 @@ public void WithLimitAndOffset()
 
             // Assert:
             Assert.Equal("SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM (GENERATED_SQL) \"results_wrapper\" WHERE ROWNUM <= ?) WHERE \"row_num\" > ?", ctx.RawSql);
-            Assert.Equal(25, ctx.Bindings[0]);
-            Assert.Equal(20, ctx.Bindings[1]);
+            Assert.Equal(25L, ctx.Bindings[0]);
+            Assert.Equal(20L, ctx.Bindings[1]);
             Assert.Equal(2, ctx.Bindings.Count);
         }
     }
diff --git a/QueryBuilder.Tests/Oracle/OracleLimitTests.cs b/QueryBuilder.Tests/Oracle/OracleLimitTests.cs
@@ -37,7 +37,7 @@ public void LimitOnly()
             //  Act & Assert:
             Assert.EndsWith("OFFSET ? ROWS FETCH NEXT ? ROWS ONLY", compiler.CompileLimit(ctx));
             Assert.Equal(2, ctx.Bindings.Count);
-            Assert.Equal(0, ctx.Bindings[0]);
+            Assert.Equal(0L, ctx.Bindings[0]);
             Assert.Equal(10, ctx.Bindings[1]);
         }
 
@@ -52,7 +52,7 @@ public void OffsetOnly()
             Assert.EndsWith("OFFSET ? ROWS", compiler.CompileLimit(ctx));
 
             Assert.Single(ctx.Bindings);
-            Assert.Equal(20, ctx.Bindings[0]);
+            Assert.Equal(20L, ctx.Bindings[0]);
         }
 
         [Fact]
@@ -66,7 +66,7 @@ public void LimitAndOffset()
             Assert.EndsWith("OFFSET ? ROWS FETCH NEXT ? ROWS ONLY", compiler.CompileLimit(ctx));
 
             Assert.Equal(2, ctx.Bindings.Count);
-            Assert.Equal(20, ctx.Bindings[0]);
+            Assert.Equal(20L, ctx.Bindings[0]);
             Assert.Equal(5, ctx.Bindings[1]);
 
             compiler.CompileLimit(ctx);
diff --git a/QueryBuilder.Tests/PostgreSql/PostgreSqlLimitTests.cs b/QueryBuilder.Tests/PostgreSql/PostgreSqlLimitTests.cs
@@ -39,7 +39,7 @@ public void WithNoLimit()
             var ctx = new SqlResult { Query = query };
 
             Assert.Equal("OFFSET ?", compiler.CompileLimit(ctx));
-            Assert.Equal(20, ctx.Bindings[0]);
+            Assert.Equal(20L, ctx.Bindings[0]);
             Assert.Single(ctx.Bindings);
         }
 
@@ -51,7 +51,7 @@ public void WithLimitAndOffset()
 
             Assert.Equal("LIMIT ? OFFSET ?", compiler.CompileLimit(ctx));
             Assert.Equal(5, ctx.Bindings[0]);
-            Assert.Equal(20, ctx.Bindings[1]);
+            Assert.Equal(20L, ctx.Bindings[1]);
             Assert.Equal(2, ctx.Bindings.Count);
         }
     }
diff --git a/QueryBuilder.Tests/SqlServer/SqlServerLimitTests.cs b/QueryBuilder.Tests/SqlServer/SqlServerLimitTests.cs
@@ -31,7 +31,7 @@ public void LimitOnly()
 
             Assert.EndsWith("OFFSET ? ROWS FETCH NEXT ? ROWS ONLY", compiler.CompileLimit(ctx));
             Assert.Equal(2, ctx.Bindings.Count);
-            Assert.Equal(0, ctx.Bindings[0]);
+            Assert.Equal(0L, ctx.Bindings[0]);
             Assert.Equal(10, ctx.Bindings[1]);
         }
 
@@ -44,7 +44,7 @@ public void OffsetOnly()
             Assert.EndsWith("OFFSET ? ROWS", compiler.CompileLimit(ctx));
 
             Assert.Single(ctx.Bindings);
-            Assert.Equal(20, ctx.Bindings[0]);
+            Assert.Equal(20L, ctx.Bindings[0]);
         }
 
         [Fact]
@@ -56,7 +56,7 @@ public void LimitAndOffset()
             Assert.EndsWith("OFFSET ? ROWS FETCH NEXT ? ROWS ONLY", compiler.CompileLimit(ctx));
 
             Assert.Equal(2, ctx.Bindings.Count);
-            Assert.Equal(20, ctx.Bindings[0]);
+            Assert.Equal(20L, ctx.Bindings[0]);
             Assert.Equal(5, ctx.Bindings[1]);
         }
 
diff --git a/QueryBuilder.Tests/Sqlite/SqliteLimitTests.cs b/QueryBuilder.Tests/Sqlite/SqliteLimitTests.cs
@@ -39,7 +39,7 @@ public void WithNoLimit()
             var ctx = new SqlResult { Query = query };
 
             Assert.Equal("LIMIT -1 OFFSET ?", compiler.CompileLimit(ctx));
-            Assert.Equal(20, ctx.Bindings[0]);
+            Assert.Equal(20L, ctx.Bindings[0]);
             Assert.Single(ctx.Bindings);
         }
 
@@ -51,7 +51,7 @@ public void WithLimitAndOffset()
 
             Assert.Equal("LIMIT ? OFFSET ?", compiler.CompileLimit(ctx));
             Assert.Equal(5, ctx.Bindings[0]);
-            Assert.Equal(20, ctx.Bindings[1]);
+            Assert.Equal(20L, ctx.Bindings[1]);
             Assert.Equal(2, ctx.Bindings.Count);
         }
     }
diff --git a/QueryBuilder/Clauses/OffsetClause.cs b/QueryBuilder/Clauses/OffsetClause.cs
@@ -2,9 +2,9 @@ namespace SqlKata
 {
     public class OffsetClause : AbstractClause
     {
-        private int _offset;
+        private long _offset;
 
-        public int Offset
+        public long Offset
         {
             get => _offset;
             set => _offset = value > 0 ? value : _offset;
diff --git a/QueryBuilder/Query.cs b/QueryBuilder/Query.cs
@@ -32,7 +32,7 @@ public Query(string table, string comment = null) : base()
 
         public bool HasLimit(string engineCode = null) => GetLimit(engineCode) > 0;
 
-        internal int GetOffset(string engineCode = null)
+        internal long GetOffset(string engineCode = null)
         {
             engineCode = engineCode ?? EngineScope;
             var offset = this.GetOneComponent<OffsetClause>("offset", engineCode);
@@ -180,7 +180,7 @@ public Query Limit(int value)
             return AddOrReplaceComponent("limit", newClause);
         }
 
-        public Query Offset(int value)
+        public Query Offset(long value)
         {
             var newClause = new OffsetClause
             {
@@ -190,6 +190,11 @@ public Query Offset(int value)
             return AddOrReplaceComponent("offset", newClause);
         }
 
+        public Query Offset(int value)
+        {
+            return Offset((long)value);
+        }
+
         /// <summary>
         /// Alias for Limit
         /// </summary>

Original file line number	Diff line number	Diff line change
`@@ -47,8 +47,8 @@ public void LimitAndOffset()`
`47`	`47`	`var ctx = new SqlResult { Query = query };`
`48`	`48`
`49`	`49`	`Assert.Equal("ROWS ? TO ?", compiler.CompileLimit(ctx));`
`50`		`- Assert.Equal(21, ctx.Bindings[0]);`
`51`		`- Assert.Equal(25, ctx.Bindings[1]);`
	`50`	`+ Assert.Equal(21L, ctx.Bindings[0]);`
	`51`	`+ Assert.Equal(25L, ctx.Bindings[1]);`
`52`	`52`	`Assert.Equal(2, ctx.Bindings.Count);`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ public void WithNoLimit()`
`39`	`39`	`var ctx = new SqlResult { Query = query };`
`40`	`40`
`41`	`41`	`Assert.Equal("LIMIT 18446744073709551615 OFFSET ?", compiler.CompileLimit(ctx));`
`42`		`- Assert.Equal(20, ctx.Bindings[0]);`
	`42`	`+ Assert.Equal(20L, ctx.Bindings[0]);`
`43`	`43`	`Assert.Single(ctx.Bindings);`
`44`	`44`	`}`
`45`	`45`
`@@ -51,7 +51,7 @@ public void WithLimitAndOffset()`
`51`	`51`
`52`	`52`	`Assert.Equal("LIMIT ? OFFSET ?", compiler.CompileLimit(ctx));`
`53`	`53`	`Assert.Equal(5, ctx.Bindings[0]);`
`54`		`- Assert.Equal(20, ctx.Bindings[1]);`
	`54`	`+ Assert.Equal(20L, ctx.Bindings[1]);`
`55`	`55`	`Assert.Equal(2, ctx.Bindings.Count);`
`56`	`56`	`}`
`57`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public void WithNoLimit()`
`58`	`58`
`59`	`59`	`// Assert:`
`60`	`60`	`Assert.Equal("SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM (GENERATED_SQL) \"results_wrapper\") WHERE \"row_num\" > ?", ctx.RawSql);`
`61`		`- Assert.Equal(20, ctx.Bindings[0]);`
	`61`	`+ Assert.Equal(20L, ctx.Bindings[0]);`
`62`	`62`	`Assert.Single(ctx.Bindings);`
`63`	`63`	`}`
`64`	`64`
`@@ -74,8 +74,8 @@ public void WithLimitAndOffset()`
`74`	`74`
`75`	`75`	`// Assert:`
`76`	`76`	`Assert.Equal("SELECT * FROM (SELECT \"results_wrapper\".*, ROWNUM \"row_num\" FROM (GENERATED_SQL) \"results_wrapper\" WHERE ROWNUM <= ?) WHERE \"row_num\" > ?", ctx.RawSql);`
`77`		`- Assert.Equal(25, ctx.Bindings[0]);`
`78`		`- Assert.Equal(20, ctx.Bindings[1]);`
	`77`	`+ Assert.Equal(25L, ctx.Bindings[0]);`
	`78`	`+ Assert.Equal(20L, ctx.Bindings[1]);`
`79`	`79`	`Assert.Equal(2, ctx.Bindings.Count);`
`80`	`80`	`}`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public void LimitOnly()`
`31`	`31`
`32`	`32`	`Assert.EndsWith("OFFSET ? ROWS FETCH NEXT ? ROWS ONLY", compiler.CompileLimit(ctx));`
`33`	`33`	`Assert.Equal(2, ctx.Bindings.Count);`
`34`		`- Assert.Equal(0, ctx.Bindings[0]);`
	`34`	`+ Assert.Equal(0L, ctx.Bindings[0]);`
`35`	`35`	`Assert.Equal(10, ctx.Bindings[1]);`
`36`	`36`	`}`
`37`	`37`
`@@ -44,7 +44,7 @@ public void OffsetOnly()`
`44`	`44`	`Assert.EndsWith("OFFSET ? ROWS", compiler.CompileLimit(ctx));`
`45`	`45`
`46`	`46`	`Assert.Single(ctx.Bindings);`
`47`		`- Assert.Equal(20, ctx.Bindings[0]);`
	`47`	`+ Assert.Equal(20L, ctx.Bindings[0]);`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`[Fact]`
`@@ -56,7 +56,7 @@ public void LimitAndOffset()`
`56`	`56`	`Assert.EndsWith("OFFSET ? ROWS FETCH NEXT ? ROWS ONLY", compiler.CompileLimit(ctx));`
`57`	`57`
`58`	`58`	`Assert.Equal(2, ctx.Bindings.Count);`
`59`		`- Assert.Equal(20, ctx.Bindings[0]);`
	`59`	`+ Assert.Equal(20L, ctx.Bindings[0]);`
`60`	`60`	`Assert.Equal(5, ctx.Bindings[1]);`
`61`	`61`	`}`
`62`	`62`
Original file line number	Diff line number	Diff line change
`@@ -2,9 +2,9 @@ namespace SqlKata`
`2`	`2`	`{`
`3`	`3`	`public class OffsetClause : AbstractClause`
`4`	`4`	`{`
`5`		`- private int _offset;`
	`5`	`+ private long _offset;`
`6`	`6`
`7`		`- public int Offset`
	`7`	`+ public long Offset`
`8`	`8`	`{`
`9`	`9`	`get => _offset;`
`10`	`10`	`set => _offset = value > 0 ? value : _offset;`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ public Query(string table, string comment = null) : base()`
`32`	`32`
`33`	`33`	`public bool HasLimit(string engineCode = null) => GetLimit(engineCode) > 0;`
`34`	`34`
`35`		`- internal int GetOffset(string engineCode = null)`
	`35`	`+ internal long GetOffset(string engineCode = null)`
`36`	`36`	`{`
`37`	`37`	`engineCode = engineCode ?? EngineScope;`
`38`	`38`	`var offset = this.GetOneComponent<OffsetClause>("offset", engineCode);`
`@@ -180,7 +180,7 @@ public Query Limit(int value)`
`180`	`180`	`return AddOrReplaceComponent("limit", newClause);`
`181`	`181`	`}`
`182`	`182`
`183`		`- public Query Offset(int value)`
	`183`	`+ public Query Offset(long value)`
`184`	`184`	`{`
`185`	`185`	`var newClause = new OffsetClause`
`186`	`186`	`{`
`@@ -190,6 +190,11 @@ public Query Offset(int value)`
`190`	`190`	`return AddOrReplaceComponent("offset", newClause);`
`191`	`191`	`}`
`192`	`192`
	`193`	`+ public Query Offset(int value)`
	`194`	`+ {`
	`195`	`+ return Offset((long)value);`
	`196`	`+ }`
	`197`	`+`
`193`	`198`	`/// <summary>`
`194`	`199`	`/// Alias for Limit`
`195`	`200`	`/// </summary>`