dev

Author: RusovDmitriy

rust/cubestore/cubestore-sql-tests/src/tests.rs

@@ -8285,20 +8285,39 @@ async fn limit_pushdown_without_group(service: Box<dyn SqlClient>) {
     );
 
     // ====================================
-    let res = assert_limit_pushdown(
+    assert_limit_pushdown(
         &service,
         "SELECT a, b, c FROM (
-                SELECT a, b, c FROM foo.pushdown_where_group1
-                union all
-                SELECT a_alias a, b_alias b, c_alias c FROM foo.pushdown_where_group2_with_alias
+                    SELECT a, b, c FROM foo.pushdown_where_group1
+                    UNION ALL
+                    SELECT a_alias a, b_alias b, c_alias c FROM foo.pushdown_where_group2_with_alias
                 ) as `tb`
-                ORDER BY 3 DESC LIMIT 3",
+                ORDER BY 3 DESC
+                LIMIT 10",
         Some("ind2"),
         true,
         true,
     )
     .await
     .unwrap();
+
+    // ====================================
+    assert_limit_pushdown(
+        &service,
+        "SELECT a, b, c FROM (
+                    SELECT a, b, c FROM foo.pushdown_where_group1
+                    UNION ALL
+                    SELECT a_alias a, b_alias b, c_alias c FROM foo.pushdown_where_group2_with_alias
+                ) as `tb`
+                WHERE b = 20
+                ORDER BY 1 DESC, 3 DESC
+                LIMIT 3",
+        Some("ind1"),
+        true,
+        true,
+    )
+    .await
+    .unwrap();
 }
 async fn limit_pushdown_without_group_resort(service: Box<dyn SqlClient>) {
     service.exec_query("CREATE SCHEMA foo").await.unwrap();

rust/cubestore/cubestore/src/queryplanner/planning.rs

@@ -769,24 +769,35 @@ impl PlanRewriter for ChooseIndex<'_> {
             LogicalPlan::Projection { expr, .. } => {
                 let alias_to_column = get_alias_to_column(expr);
 
-                if let Some(sort) = &context.sort {
+                let new_single_value_filtered_cols = context
+                    .single_value_filtered_cols
+                    .iter()
+                    .map(|name| {
+                        alias_to_column
+                            .get(name)
+                            .map_or_else(|| name.clone(), |col| col.name.clone())
+                    })
+                    .collect();
+
+                let mut new_context =
+                    context.update_single_value_filtered_cols(new_single_value_filtered_cols);
+
+                if let Some(sort) = &new_context.sort {
                     let names: Vec<String> = sort
-                        .clone()
                         .iter()
                         .map(|k| {
                             alias_to_column
                                 .get(k)
-                                .map_or_else(|| k.clone(), |v| v.name.clone())
+                                .map_or_else(|| k.clone(), |col| col.name.clone())
                         })
                         .collect();
 
                     if !names.is_empty() {
-                        return Some(context.update_sort(names, context.sort_is_asc));
-                    } else {
-                        return None;
+                        new_context = new_context.update_sort(names, context.sort_is_asc);
                     }
                 }
-                None
+
+                Some(new_context)
             }
             LogicalPlan::Limit { n, .. } => Some(context.update_limit(Some(*n))),
             LogicalPlan::Skip { n, .. } => {