Break up Offset and Limit into seperate classes.

Author: bordoley

SQLitePCL.pretty.Orm/SQLitePCL.pretty.Orm.csproj

@@ -152,6 +152,9 @@
     <Compile Include="Reflection.cs" />
     <Compile Include="ForeignKeyConstraint.cs" />
     <Compile Include="SqlQuery.cs" />
+    <Compile Include="SqlQuery.Offset.cs">
+      <DependentUpon>SqlQuery.cs</DependentUpon>
+    </Compile>
     <Compile Include="SqlQuery.Limit.cs">
       <DependentUpon>SqlQuery.cs</DependentUpon>
     </Compile>

SQLitePCL.pretty.Orm/SqlQuery.Limit.cs

@@ -15,35 +15,22 @@ public sealed class LimitClause<T> : ISqlQuery
         {
             private readonly OrderByClause<T> orderBy;
             private readonly int limit;
-            private readonly Nullable<int> offset;
 
-            internal LimitClause(OrderByClause<T> orderBy, int limit, Nullable<int> offset)
+            internal LimitClause(OrderByClause<T> orderBy, int limit)
             {
                 this.orderBy = orderBy;
                 this.limit = limit;
-                this.offset = offset;
             }
 
             /// <summary>
-            /// Returns a <see cref="LimitClause&lt;T&gt;"/> that limits the result set to a specified number of contiguous elements.
-            /// </summary>
-            /// <param name="n">The number of elements to return.</param>
-            /// <returns>A new <see cref="LimitClause&lt;T&gt;"/>.</returns>
-            public LimitClause<T> Take(int n)
-            {
-                Contract.Requires(n >= 0);
-                return new LimitClause<T>(orderBy, n, offset);
-            }
-
-            /// <summary>
-            /// Returns a <see cref="LimitClause&lt;T&gt;"/> that skips a specified number of elements in the result set and then returns the remaining elements.
+            /// Returns a <see cref="OffsetClause&lt;T&gt;"/> that skips a specified number of elements in the result set and then returns the remaining elements.
             /// </summary>
             /// <param name="n">The number of elements to skip before returning the remaining elements.</param>
-            /// <returns>A new <see cref="LimitClause&lt;T&gt;"/>.</returns>
-            public LimitClause<T> Skip(int n)
+            /// <returns>A new <see cref="OffsetClause&lt;T&gt;"/>.</returns>
+            public OffsetClause<T> Skip(int n)
             {
                 Contract.Requires(n >= 0);
-                return new LimitClause<T>(orderBy, limit, n);
+                return new OffsetClause<T>(this, n);
             }
 
             /// <summary>
@@ -54,8 +41,7 @@ public override string ToString()
             {
                 return 
                     orderBy.ToString() +
-                    "\r\nLIMIT " + limit +
-                    (offset.HasValue ? "\r\nOFFSET " + offset.Value : "");
+                    "\r\nLIMIT " + limit;
             }
         }
     }

SQLitePCL.pretty.Orm/SqlQuery.Offset.cs

@@ -0,0 +1,34 @@
+using System;
+namespace SQLitePCL.pretty.Orm
+{
+    public static partial class SqlQuery
+    {
+        /// <summary>
+        /// The OFFSET clause of a SQL query.
+        /// </summary>
+        public sealed class OffsetClause<T> : ISqlQuery
+        {
+            private readonly LimitClause<T> limit;
+            private readonly int offset;
+
+            internal OffsetClause(LimitClause<T> limit, int offset)
+            {
+                this.limit = limit;
+                this.offset = offset;
+            }
+
+            /// <summary>
+            /// Returns a <see cref="System.String"/> that represents the current <see cref="OffsetClause&lt;T&gt;"/>.
+            /// </summary>
+            /// <returns>A <see cref="System.String"/> that represents the current <see cref="OffsetClause&lt;T&gt;"/>.</returns>
+
+            public override string ToString()
+            {
+                return 
+                    limit.ToString() +
+                    "\r\nOFFSET " + offset;
+            }
+        }
+    }
+}
+

SQLitePCL.pretty.Orm/SqlQuery.OrderBy.cs

@@ -57,31 +57,29 @@ public OrderByClause<T> ThenByDescending<TValue>(Expression<Func<T, TValue>> ord
             public LimitClause<T> Take(int n)
             {
                 Contract.Requires(n >= 0);
-                return new LimitClause<T>(this, n, null);
+                return new LimitClause<T>(this, n);
             }
 
             /// <summary>
-            /// Returns a <see cref="LimitClause&lt;T&gt;"/> that skips a specified number of elements in the result set and then returns the remaining elements.
+            /// Returns a <see cref="OffsetClause&lt;T&gt;"/> that skips a specified number of elements in the result set and then returns the remaining elements.
             /// </summary>
             /// <param name="n">The number of elements to skip before returning the remaining elements.</param>
-            /// <returns>A new <see cref="LimitClause&lt;T&gt;"/>.</returns>
-            public LimitClause<T> Skip(int n)
+            /// <returns>A new <see cref="OffsetClause&lt;T&gt;"/>.</returns>
+            public OffsetClause<T> Skip(int n)
             {
-                Contract.Requires(n >= 0);
-
                 //If the LIMIT expression evaluates to a negative value, then there is no upper bound on the number of rows returned
-                return new LimitClause<T>(this, -1, n);
+                return new LimitClause<T>(this, -1).Skip(n);
             }
 
             /// <summary>
-            /// Returns a <see cref="LimitClause&lt;T&gt;"/> that returns the element at a specified index in the result set.
+            /// Returns a <see cref="OffsetClause&lt;T&gt;"/> that returns the element at a specified index in the result set.
             /// </summary>
-            /// <param name="index">Index.</param>
-            /// <returns>A new <see cref="LimitClause&lt;T&gt;"/>.</returns>
-            public LimitClause<T> ElementAt(int index)
+            /// <param name="index">The index of the element to retrieve.</param>
+            /// <returns>A new <see cref="OffsetClause&lt;T&gt;"/>.</returns>
+            public OffsetClause<T> ElementAt(int index)
             {
                 Contract.Requires(index >= 0);
-                return Skip(index).Take(1);
+                return this.Take(1).Skip(index);
             }
 
             private OrderByClause<T> AddOrderBy<TValue>(Expression<Func<T, TValue>> orderExpr, bool asc)

SQLitePCL.pretty.Orm/SqlQuery.Select.cs

@@ -157,22 +157,22 @@ public LimitClause<T> Take(int n)
             }
 
             /// <summary>
-            /// Returns a <see cref="LimitClause&lt;T&gt;"/> that skips a specified number of elements in the result set and then returns the remaining elements.
+            /// Returns a <see cref="OffsetClause&lt;T&gt;"/> that skips a specified number of elements in the result set and then returns the remaining elements.
             /// </summary>
             /// <param name="n">The number of elements to skip before returning the remaining elements.</param>
             /// <returns>A new <see cref="LimitClause&lt;T&gt;"/>.</returns>
-            public LimitClause<T> Skip(int n)
+            public OffsetClause<T> Skip(int n)
             {
                 return this.Where().Skip(n);
             }
 
             /// <summary>
-            /// Returns a <see cref="LimitClause&lt;T&gt;"/> that returns the element at a specified index in the result set.
+            /// Returns a <see cref="OffsetClause&lt;T&gt;"/> that returns the element at a specified index in the result set.
             /// </summary>
-            /// <returns>The <see cref="LimitClause&lt;T&gt;"/>.</returns>
-            /// <param name="index">Index.</param>
-            /// <returns>A new <see cref="LimitClause&lt;T&gt;"/>.</returns>
-            public LimitClause<T> ElementAt(int index)
+            /// <returns>The <see cref="OffsetClause&lt;T&gt;"/>.</returns>
+            /// <param name="index">The index of the element to retrieve.</param>
+            /// <returns>A new <see cref="OffsetClause&lt;T&gt;"/>.</returns>
+            public OffsetClause<T> ElementAt(int index)
             {
                 return this.Where().ElementAt(index);
             }

SQLitePCL.pretty.Orm/SqlQuery.Where.cs

@@ -78,7 +78,7 @@ public LimitClause<T> Take(int n)
             /// </summary>
             /// <param name="n">The number of elements to skip before returning the remaining elements.</param>
             /// <returns>A new <see cref="LimitClause&lt;T&gt;"/>.</returns>
-            public LimitClause<T> Skip(int n)
+            public OffsetClause<T> Skip(int n)
             {
                 return this.OrderByNone().Skip(n);
             }
@@ -87,9 +87,9 @@ public LimitClause<T> Skip(int n)
             /// Returns a <see cref="LimitClause&lt;T&gt;"/> that returns the element at a specified index in the result set.
             /// </summary>
             /// <returns>The <see cref="LimitClause&lt;T&gt;"/>.</returns>
-            /// <param name="index">Index.</param>
+            /// <param name="index">The index of the element to retrieve.</param>
             /// <returns>A new <see cref="LimitClause&lt;T&gt;"/>.</returns>
-            public LimitClause<T> ElementAt(int index)
+            public OffsetClause<T> ElementAt(int index)
             {
                 return this.OrderByNone().ElementAt(index);
             }