Merge pull request #43427 from poorna2152/order_by_arr

Fix hanging of query when the key in order is an array

langlib/lang.query/build.gradle

@@ -33,6 +33,7 @@ dependencies {
     distributionBala project(path: ':ballerina-lang:table', configuration: 'distributionBala')
     distributionBala project(path: ':ballerina-lang:stream', configuration: 'distributionBala')
     distributionBala project(path: ':ballerina-lang:error', configuration: 'distributionBala')
+    distributionBala project(path: ':ballerina-lang:function', configuration: 'distributionBala')
     distributionBala project(path: ':ballerina-lang:jballerina.java', configuration: 'distributionBala')
     distributionBala project(path: ':ballerina-lang:object', configuration: 'distributionBala')
 

langlib/lang.query/src/main/ballerina/types.bal

@@ -22,6 +22,7 @@ import ballerina/lang.'xml as lang_xml;
 import ballerina/lang.'stream as lang_stream;
 import ballerina/lang.'table as lang_table;
 import ballerina/lang.'object as lang_object;
+import ballerina/lang.'function;
 
 # A type parameter that is a subtype of `any|error`.
 # Has the special semantic that when used in a declaration
@@ -1053,39 +1054,14 @@ class _OrderTreeNode {
         return orderedFrames;
     }
 
-    # sorting is not supported for any[], therefore have to resolve runtime type and sort it.
+    # sorting is not supported for any[], thus use the `function:call` method call the sort operation.
     # + return - ordered array.
     function getSortedArray(any[] arr) returns any[] {
-        if (arr.length() > 0) {
-            int i = 0;
-            while (i < arr.length()) {
-                if (arr[i] is ()) {
-                    i += 1;
-                    continue;
-                } else if (arr[i] is boolean) {
-                    boolean?[] res = [];
-                    self.copyArray(arr, res);
-                    return res.sort(self.nodesDirection, (v) => v);
-                } else if (arr[i] is int) {
-                    int?[] res = [];
-                    self.copyArray(arr, res);
-                    return res.sort(self.nodesDirection, (v) => v);
-                } else if (arr[i] is float) {
-                    float?[] res = [];
-                    self.copyArray(arr, res);
-                    return res.sort(self.nodesDirection, (v) => v);
-                } else if (arr[i] is decimal) {
-                    decimal?[] res = [];
-                    self.copyArray(arr, res);
-                    return res.sort(self.nodesDirection, (v) => v);
-                } else if (arr[i] is string) {
-                    string?[] res = [];
-                    self.copyArray(arr, res);
-                    return res.sort(self.nodesDirection, (v) => v);
-                }
-            }
+        any|error res = function:call(lang_array:sort, arr, self.nodesDirection);
+        if res is any[] {
+            return res;
         }
-        return arr;
+        panic error(string `Error while sorting the arr: ${arr.toBalString()}`);
     }
 
     # copy every element of source array into empty target array.

tests/jballerina-unit-test/src/test/java/org/ballerinalang/test/query/OrderByClauseTest.java

@@ -233,17 +233,28 @@ public void testQueryExprWithOrderByClauseReturnXML() {
 
     @Test(description = "Test negative scenarios for query expr with order by clause")
     public void testNegativeScenarios() {
-        Assert.assertEquals(negativeResult.getErrorCount(), 3);
         int index = 0;
 
         validateError(negativeResult, index++, "order by not supported for complex type fields, " +
                         "order key should belong to a basic type",
                 35, 18);
         validateError(negativeResult, index++, "undefined symbol 'address'",
                 35, 18);
-        validateError(negativeResult, index, "order by not supported for complex type fields, " +
-                        "order key should belong to a basic type",
+        validateError(negativeResult, index++,
+                "order by not supported for complex type fields, order key should belong to a basic type",
                 47, 18);
+        validateError(negativeResult, index++,
+                "order by not supported for complex type fields, order key should belong to a basic type",
+                55, 18);
+        validateError(negativeResult, index++,
+                "order by not supported for complex type fields, order key should belong to a basic type",
+                61, 18);
+        Assert.assertEquals(negativeResult.getErrorCount(), index);
+    }
+
+    @Test
+    public void testQueryExprWithOrderByClauseWithArrayKey() {
+        BRunUtil.invoke(result, "testQueryExprWithOrderByClauseWithArrayKey");
     }
 
     @AfterClass

tests/jballerina-unit-test/src/test/resources/test-src/query/order-by-clause-negative.bal

@@ -47,3 +47,17 @@ function testOrderByClauseWithComplexTypeFieldInOrderBy() {
         order by customer.address
         select customer;
 }
+
+function testOrderByClauseWithArrayTypeFieldInOrderBy() {
+    record {|(int|boolean)[] t; string s;|}[] data1 = [];
+
+    _ = from var rec in data1
+        order by rec.t descending
+        select rec.s;
+
+    record {|int k; [decimal|float, int] arr;|}[] data2 = [];
+
+    _ = from var rec in data2
+        order by rec.arr
+        select rec.k;
+}

tests/jballerina-unit-test/src/test/resources/test-src/query/order-by-clause.bal

@@ -502,3 +502,117 @@ function incrementCount(int i) returns int {
     int count = i + 2;
     return count;
 }
+
+enum Color {
+    RED,
+    GREEN,
+    BLUE
+}
+
+function testQueryExprWithOrderByClauseWithArrayKey() {
+    record {|int[] t; string s;|}[] data1 = [
+        {s: "s5", t: [5, 2]},
+        {s: "s1", t: [1, 1, 3, 4]},
+        {s: "s0", t: [0]},
+        {s: "s4", t: [4]}
+    ];
+
+    string[] q1 = from var rec in data1
+        order by rec.t descending
+        select rec.s;
+    assertEquality(["s5", "s4", "s1", "s0"], q1);
+
+    record {|int k; [decimal, int] arr;|}[] data2 = [
+        {k: 1, arr: [3.2, 1]},
+        {k: 2, arr: [212.21, 3]},
+        {k: 3, arr: [0.2, 4]},
+        {k: 4, arr: [-1.2, 10]}
+    ];
+
+    int[] q2 = from var rec in data2
+        order by rec.arr descending
+        select rec.k;
+    assertEquality([2, 1, 3, 4], q2);
+
+    record {|int k; [boolean, string, int] arr;|}[] data3 = [
+        {k: 1, arr: [true, "abcd", 1]},
+        {k: 2, arr: [false, "efgh", 9]},
+        {k: 3, arr: [false, "abcd", 10]},
+        {k: 4, arr: [true, "ijkl", -5]}
+    ];
+
+    int[] q3 = from var rec in data3
+        order by rec.arr
+        select rec.k;
+    assertEquality([3, 2, 1, 4], q3);
+
+    record {|int k; [float...] arr;|}[] data4 = [
+        {k: 1, arr: [1.2, 3.1, 5.6, 9.2]},
+        {k: 2, arr: []},
+        {k: 3, arr: [-0.7, 0.8, 1.45]},
+        {k: 4, arr: [1, 2]}
+    ];
+
+    int[] q4 = from var rec in data4
+        order by rec.arr
+        select rec.k;
+    assertEquality([2, 3, 4, 1], q4);
+
+    record {|int k; [float...] arr1; [string, string...] arr2;|}[] data5 = [
+        {k: 1, arr1: [1.2, 3.1, 5.6, 9.2], arr2: ["s1", "s2"]},
+        {k: 2, arr1: [], arr2: ["s10", "s9"]},
+        {k: 3, arr1: [], arr2: ["s1", "s2"]},
+        {k: 4, arr1: [], arr2: ["s1", "s2"]},
+        {k: 5, arr1: [1, 2], arr2: ["s24", "s2"]}
+    ];
+
+    int[] q5 = from var rec in data5
+        order by rec.arr1 descending, rec.arr2 ascending
+        select rec.k;
+    assertEquality([1, 5, 3, 4, 2], q5);
+
+    record {|int k; float?[]? arr1;|}[] data6 = [
+        {k: 1, arr1: [1.2, 3.1, 5.6, 9.2]},
+        {k: 2, arr1: [1.2, 3.1, 5.6, ()]},
+        {k: 3, arr1: [(), (), ()]},
+        {k: 4, arr1: ()},
+        {k: 5, arr1: [1, 2]}
+    ];
+
+    int[] q6 = from var rec in data6
+        order by rec.arr1 descending
+        select rec.k;
+    assertEquality([1, 2, 5, 3, 4], q6);
+
+    record {|int k; [int?, string?, decimal?...] arr1;|}[] data7 = [
+        {k: 1, arr1: [1, "a", 9.2]},
+        {k: 2, arr1: [1, (), ()]},
+        {k: 3, arr1: [(), (), 4.2]},
+        {k: 4, arr1: [2, "b"]},
+        {k: 5, arr1: [2, (), 2.3]}
+    ];
+
+    int[] q7 = from var rec in data7
+        order by rec.arr1 descending
+        select rec.k;
+    assertEquality([4, 5, 1, 2, 3], q7);
+
+    record {|int k; Color[] arr1;|}[] data8 = [
+        {k: 1, arr1: [RED]},
+        {k: 2, arr1: [RED, GREEN]},
+        {k: 3, arr1: [GREEN, BLUE, RED]},
+        {k: 4, arr1: [BLUE, RED]},
+        {k: 5, arr1: [BLUE, BLUE]}
+    ];
+
+    int[] q8 = from var rec in data8
+        order by rec.arr1 descending
+        select rec.k;
+    assertEquality([2, 1, 3, 4, 5], q8);
+}
+
+function assertEquality(anydata expected, anydata actual) {
+    if expected != actual {
+        panic error(string `Expected ${expected.toBalString()}, found ${actual.toBalString()}`);
+    }
+}