add option to always to require orderby with limit

Author: pedrocarlo

testing/differential-oracle/fuzzer/generate.rs

@@ -63,6 +63,7 @@ impl SqlGenBackend {
             );
         policy.select_config.nulls_order_weights.first = 0;
         policy.select_config.nulls_order_weights.last = 0;
+        policy.select_config.require_order_by_with_limit = true;
         // Disable expression values and conflict clauses for now
         policy.insert_config.expression_value_probability = 0.0;
         policy.insert_config.or_replace_probability = 0.0;

testing/differential-oracle/sql_gen/src/generate/select.rs

@@ -229,7 +229,7 @@ fn generate_select_impl_inner<C: Capabilities>(
     };
 
     // --- ORDER BY ---
-    let order_by = if ctx.gen_bool_with_prob(order_by_prob) {
+    let mut order_by = if ctx.gen_bool_with_prob(order_by_prob) {
         if let Some(gb) = &group_by {
             generate_grouped_order_by(generator, ctx, &gb.exprs)?
         } else {
@@ -255,6 +255,15 @@ fn generate_select_impl_inner<C: Capabilities>(
         SelectMode::Scalar => (Some(1), None),
     };
 
+    // Enforce deterministic LIMIT semantics when configured.
+    if limit.is_some() && order_by.is_empty() && select_config.require_order_by_with_limit {
+        order_by = if let Some(gb) = &group_by {
+            generate_grouped_order_by(generator, ctx, &gb.exprs)?
+        } else {
+            generate_order_by(generator, ctx)?
+        };
+    }
+
     let from = {
         let primary_name = ctx.tables_in_scope()[0].table.name.clone();
         let primary_qualifier = ctx.tables_in_scope()[0].qualifier.clone();
@@ -1442,4 +1451,35 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn test_require_order_by_with_limit_policy() {
+        let policy = Policy::default().with_select_config(crate::policy::SelectConfig {
+            limit_probability: 1.0,
+            order_by_probability: 0.0,
+            require_order_by_with_limit: true,
+            ..Default::default()
+        });
+        let schema = SchemaBuilder::new()
+            .table(Table::new(
+                "users",
+                vec![
+                    ColumnDef::new("id", DataType::Integer).primary_key(),
+                    ColumnDef::new("name", DataType::Text),
+                    ColumnDef::new("age", DataType::Integer),
+                ],
+            ))
+            .build();
+        let generator: SqlGen<Full> = SqlGen::new(schema, policy);
+
+        for seed in 0..50 {
+            let mut ctx = Context::new_with_seed(seed);
+            let select = generate_select_impl(&generator, &mut ctx, SelectMode::Full).unwrap();
+            assert!(select.limit.is_some(), "Expected LIMIT to be present");
+            assert!(
+                !select.order_by.is_empty(),
+                "Expected ORDER BY when LIMIT is present with require_order_by_with_limit=true"
+            );
+        }
+    }
 }

testing/differential-oracle/sql_gen/src/policy.rs

@@ -991,6 +991,10 @@ pub struct SelectConfig {
     /// Probability of generating LIMIT clause.
     pub limit_probability: f64,
 
+    /// When true, any SELECT that has a LIMIT will also include ORDER BY.
+    /// This avoids undefined row-order behavior from unordered LIMIT queries.
+    pub require_order_by_with_limit: bool,
+
     /// Probability of generating OFFSET clause (only if LIMIT exists).
     pub offset_probability: f64,
 
@@ -1068,6 +1072,7 @@ impl Default for SelectConfig {
             where_probability: 0.9,
             order_by_probability: 0.7,
             limit_probability: 0.6,
+            require_order_by_with_limit: false,
             offset_probability: 0.4,
             group_by_probability: 0.3,
             having_probability: 0.5,
@@ -1100,6 +1105,7 @@ impl SelectConfig {
             where_probability: 0.0,
             order_by_probability: 0.0,
             limit_probability: 0.0,
+            require_order_by_with_limit: false,
             offset_probability: 0.0,
             group_by_probability: 0.0,
             having_probability: 0.0,
@@ -1117,6 +1123,7 @@ impl SelectConfig {
             where_probability: 0.95,
             order_by_probability: 0.8,
             limit_probability: 0.7,
+            require_order_by_with_limit: false,
             offset_probability: 0.5,
             group_by_probability: 0.5,
             having_probability: 0.6,
@@ -2040,9 +2047,11 @@ mod tests {
         let config = SelectConfig::simple();
         assert_eq!(config.where_probability, 0.0);
         assert_eq!(config.order_by_probability, 0.0);
+        assert!(!config.require_order_by_with_limit);
 
         let complex = SelectConfig::complex();
         assert!(complex.where_probability > 0.5);
+        assert!(!complex.require_order_by_with_limit);
     }
 
     #[test]