Fix SQL Vector_Builder to work with deeper structures (#13030)

This fixes a Stack Overflow error occurring when running Snowflake tests.

The `Vector_Builder` that is used under the hood in the SQL builder was relying on non-tail recursion, meaning that if the structure to be built was nested too deeply, it could overflow the stack.

This PR addresses that by rewriting the `build` method to keep a stack on the heap, thus making the main loop tail-recursive. It adds a tests of `Vector_Builder` that verifies it can build very large structures of various shapes. The test case that builds 4 vectors that total 24000 elements finishes in ~0.5s on my machine.

Author: radeusgd

distribution/lib/Standard/Table/0.0.0-dev/src/Internal/Vector_Builder.enso

@@ -56,12 +56,16 @@ type Vector_Builder
     build : Vector Any
     build self =
         Vector.build initial_capacity=self.length vec_builder->
-            go elem = case elem of
-                Leaf vec -> vec_builder.append_vector_range vec
-                Append l r _ ->
-                    go l
-                    go r
-            go self
+            go stack = case stack of
+                List.Nil -> Nothing
+                List.Cons elem rest ->
+                    case elem of
+                        Leaf vec ->
+                            vec_builder.append_vector_range vec
+                            @Tail_Call go rest
+                        Append l r _ ->
+                            @Tail_Call go (List.Cons l (List.Cons r rest))
+            go (List.Cons self List.Nil)
 
     ## PRIVATE
 
@@ -94,4 +98,3 @@ type Vector_Builder
        - vec: The vector to create a vector builder from.
     from_vector : Vector Any -> Vector_Builder Any
     from_vector vec = Leaf vec
-

test/Table_Tests/src/Helpers/Main.enso

@@ -6,12 +6,14 @@ import project.Helpers.Sorted_List_Index_Spec
 import project.Helpers.SQL_Statement_Serialization
 import project.Helpers.Unique_Naming_Strategy_Spec
 import project.Helpers.Value_Type_Spec
+import project.Helpers.Vector_Builder_Spec
 
 add_specs suite_builder =
     Unique_Naming_Strategy_Spec.add_specs suite_builder
     Sorted_List_Index_Spec.add_specs suite_builder
     SQL_Statement_Serialization.add_specs suite_builder
     Value_Type_Spec.add_specs suite_builder
+    Vector_Builder_Spec.add_specs suite_builder
 
 main filter=Nothing =
     suite = Test.build suite_builder->

test/Table_Tests/src/Helpers/Vector_Builder_Spec.enso

@@ -0,0 +1,65 @@
+from Standard.Base import all
+
+import Standard.Table.Internal.Vector_Builder.Vector_Builder
+
+from Standard.Test import all
+
+add_specs suite_builder =
+    suite_builder.group "Vector_Builder" group_builder->
+        # Tests added because early implementation of Vector_Builder was overflowing the stack for larger vectors
+        group_builder.specify "should be able to concatenate lots of elements" <|
+            vb1 = 0.up_to 1000 . fold Vector_Builder.empty acc-> i->
+                acc ++ [i]
+            v1 = vb1.build
+            v1.should_be_a Vector
+            v1.length . should_equal 1000
+            v1.should_equal (Vector.new 1000 i->i)
+
+            vb2 = 0.up_to 1000 . fold Vector_Builder.empty acc-> i->
+                Vector_Builder.from_vector [i] ++ acc
+            v2 = vb2.build
+            v2.length . should_equal 1000
+            v2.should_equal (Vector.new 1000 i->i).reverse
+
+            vb3 = 0.up_to 10000 . fold Vector_Builder.empty acc-> i->
+                if i % 2 == 0 then acc ++ ["."] else
+                    Vector_Builder.from_vector ["."] ++ acc
+            v3 = vb3.build
+            v3.length . should_equal 10000
+            v3.should_equal (Vector.new 10000 _->".")
+
+            vb4 = vb1 ++ vb2 ++ vb3
+            v4 = vb4.build
+            v4.length . should_equal 12000
+            v4.should_equal ((Vector.new 1000 i->i) + (Vector.new 1000 i->i).reverse + (Vector.new 10000 _->"."))
+
+        group_builder.specify "should keep correct ordering" <|
+            vb1 = 0.up_to 100 . fold Vector_Builder.empty acc-> i->
+                acc ++ [i, 10*i]
+            v1 = vb1.build
+            v1.should_be_a Vector
+            v1.length . should_equal 200
+            v1.should_equal (Vector.new 100 i->[i, 10*i]).flatten
+
+            vb2 = 0.up_to 100 . fold Vector_Builder.empty acc-> i->
+                Vector_Builder.from_vector [i, 10*i] ++ acc
+            v2 = vb2.build
+            v2.length . should_equal 200
+            ev2 = Vector.new 100 j->
+                i = 99 - j
+                [i, 10*i]
+            v2.should_equal ev2.flatten
+
+            abc = Vector_Builder.from_vector ["a", "b", "c"]
+            vb3 = 0.up_to 500 . fold Vector_Builder.empty acc-> i->
+                if i % 2 == 0 then acc ++ abc else
+                    abc ++ acc
+            v3 = vb3.build
+            v3.length . should_equal 1500
+            v3.should_equal (Vector.new 500 _->["a", "b", "c"]).flatten
+
+
+main filter=Nothing =
+    suite = Test.build suite_builder->
+        add_specs suite_builder
+    suite.run_with_filter filter