Limit/offset special case with no defined order by

src/visitor/mssql.rs

@@ -1,13 +1,14 @@
 use super::Visitor;
 use crate::{
-    ast::{OnConflict, Row, Values},
+    ast::{Column, OnConflict, Order, Ordering, Row, Values},
     Value,
 };
 use std::fmt::{self, Write};
 
 pub struct Mssql<'a> {
     query: String,
     parameters: Vec<Value<'a>>,
+    order_by_set: bool,
 }
 
 impl<'a> Visitor<'a> for Mssql<'a> {
@@ -21,6 +22,7 @@ impl<'a> Visitor<'a> for Mssql<'a> {
         let mut this = Mssql {
             query: String::with_capacity(4096),
             parameters: Vec::with_capacity(128),
+            order_by_set: false,
         };
 
         Mssql::visit_query(&mut this, query.into());
@@ -37,25 +39,40 @@ impl<'a> Visitor<'a> for Mssql<'a> {
     }
 
     fn visit_limit_and_offset(&mut self, limit: Option<Value<'a>>, offset: Option<Value<'a>>) -> fmt::Result {
+        let add_ordering = |this: &mut Self| {
+            if !this.order_by_set {
+                this.write(" ORDER BY ")?;
+                this.visit_ordering(Ordering::new(vec![(Column::from("1").into(), None)]))?;
+            }
+
+            Ok::<(), fmt::Error>(())
+        };
+
         match (limit, offset) {
             (Some(limit), Some(offset)) => {
+                add_ordering(self)?;
+
                 self.write(" OFFSET ")?;
                 self.visit_parameterized(offset)?;
                 self.write(" ROWS FETCH NEXT ")?;
                 self.visit_parameterized(limit)?;
-                self.write(" ROWS ONLY ")
+                self.write(" ROWS ONLY")
             }
             (None, Some(offset)) => {
+                add_ordering(self)?;
+
                 self.write(" OFFSET ")?;
                 self.visit_parameterized(offset)?;
-                self.write(" ROWS ")
+                self.write(" ROWS")
             }
             (Some(limit), None) => {
+                add_ordering(self)?;
+
                 self.write(" OFFSET ")?;
                 self.visit_parameterized(Value::from(0))?;
                 self.write(" ROWS FETCH NEXT ")?;
                 self.visit_parameterized(limit)?;
-                self.write(" ROWS ONLY ")
+                self.write(" ROWS ONLY")
             }
             (None, None) => Ok(()),
         }
@@ -147,6 +164,28 @@ impl<'a> Visitor<'a> for Mssql<'a> {
             Ok(())
         })
     }
+
+    fn visit_ordering(&mut self, ordering: Ordering<'a>) -> fmt::Result {
+        let len = ordering.0.len();
+
+        for (i, (value, ordering)) in ordering.0.into_iter().enumerate() {
+            let direction = ordering.map(|dir| match dir {
+                Order::Asc => " ASC",
+                Order::Desc => " DESC",
+            });
+
+            self.visit_expression(value)?;
+            self.write(direction.unwrap_or(""))?;
+
+            if i < (len - 1) {
+                self.write(", ")?;
+            }
+        }
+
+        self.order_by_set = true;
+
+        Ok(())
+    }
 }
 
 #[cfg(test)]
@@ -552,4 +591,48 @@ mod tests {
 
         assert_eq!(expected_sql, sql);
     }
+
+    #[test]
+    fn test_limit_with_no_offset() {
+        let expected_sql = "SELECT foo FROM bar ORDER BY id OFFSET @P1 ROWS FETCH NEXT @P2 ROWS ONLY";
+        let query = Select::from_table("bar").column("foo").order_by("id").limit(10);
+        let (sql, params) = Mssql::build(query);
+
+        assert_eq!(expected_sql, sql);
+        assert_eq!(vec![Value::Integer(0), Value::Integer(10)], params);
+    }
+
+    #[test]
+    fn test_offset_no_limit() {
+        let expected_sql = "SELECT foo FROM bar ORDER BY id OFFSET @P1 ROWS";
+        let query = Select::from_table("bar").column("foo").order_by("id").offset(10);
+        let (sql, params) = Mssql::build(query);
+
+        assert_eq!(expected_sql, sql);
+        assert_eq!(vec![Value::Integer(10)], params);
+    }
+
+    #[test]
+    fn test_limit_with_offset() {
+        let expected_sql = "SELECT foo FROM bar ORDER BY id OFFSET @P1 ROWS FETCH NEXT @P2 ROWS ONLY";
+        let query = Select::from_table("bar")
+            .column("foo")
+            .order_by("id")
+            .limit(9)
+            .offset(10);
+        let (sql, params) = Mssql::build(query);
+
+        assert_eq!(expected_sql, sql);
+        assert_eq!(vec![Value::Integer(10), Value::Integer(9)], params);
+    }
+
+    #[test]
+    fn test_limit_with_offset_no_given_order() {
+        let expected_sql = "SELECT foo FROM bar ORDER BY 1 OFFSET @P1 ROWS FETCH NEXT @P2 ROWS ONLY";
+        let query = Select::from_table("bar").column("foo").limit(9).offset(10);
+        let (sql, params) = Mssql::build(query);
+
+        assert_eq!(expected_sql, sql);
+        assert_eq!(vec![Value::Integer(10), Value::Integer(9)], params);
+    }
 }