Implement Table.replace for the database backend

CHANGELOG.md

@@ -611,6 +611,7 @@
   `Filter_Condition`.][8865]
 - [Added `File_By_Line` type allowing processing a file line by line. New faster
   JSON parser based off Jackson.][8719]
+- [Implemented `Table.replace` for the in-memory backend.][8935]
 
 [debug-shortcuts]:
   https://github.com/enso-org/enso/blob/develop/app/gui/docs/product/shortcuts.md#debug
@@ -878,6 +879,7 @@
 [8816]: https://github.com/enso-org/enso/pull/8816
 [8849]: https://github.com/enso-org/enso/pull/8849
 [8865]: https://github.com/enso-org/enso/pull/8865
+[8935]: https://github.com/enso-org/enso/pull/8935
 
 #### Enso Compiler
 

distribution/lib/Standard/Base/0.0.0-dev/src/Data/Vector/Extensions.enso

@@ -0,0 +1,55 @@
+import project.Any.Any
+import project.Data.Array.Array
+import project.Data.Vector.Vector
+import project.Error.Error
+import project.Errors.Illegal_Argument.Illegal_Argument
+import project.Runtime
+
+## GROUP Selections
+   Swaps the rows and columns of a matrix represented by a `Vector` of `Vectors`.
+
+   ! Error Conditions
+
+     - If the rowws (subvectors) do not all have the same length, an
+     `Illegal_Argument` error is raised.
+
+   > Example
+     Transpose a `Vector` of `Vectors`.`
+
+         "Hello, world!".reverse
+
+         matrix = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
+         # +---+---+---+
+         # | 0 | 1 | 2 |
+         # +---+---+---+
+         # | 3 | 4 | 5 |
+         # +---+---+---+
+         # | 6 | 7 | 8 |
+         # +---+---+---+
+
+         transposed = [[0, 3, 6], [1, 4, 7], [2, 5, 8]]
+         # +---+---+---+
+         # | 0 | 3 | 6 |
+         # +---+---+---+
+         # | 1 | 4 | 7 |
+         # +---+---+---+
+         # | 2 | 5 | 8 |
+         # +---+---+---+
+
+         matrix.transposed == transposed
+         # => True
+Vector.transpose : Vector (Vector Any) ! Illegal_Argument
+Vector.transpose self =
+    if self.is_empty then [] else
+        length = self.length
+        first_subvector_length = self.at 0 . length
+        builders = Vector.new first_subvector_length (_-> Vector.new_builder length)
+        result = self.map v->
+            if v.length != first_subvector_length then Error.throw (Illegal_Argument.Error "Transpose requires that all rows be the same length") else
+                v.map_with_index i-> x->
+                    builders.at i . append x
+        result.if_not_error <|
+            builders.map .to_vector
+
+Array.transpose : Vector (Vector Any) ! Illegal_Argument
+Array.transpose self = Vector.transpose self

distribution/lib/Standard/Database/0.0.0-dev/src/Data/Table.enso

@@ -34,6 +34,7 @@ import Standard.Table.Internal.Aggregate_Column_Helper
 import Standard.Table.Internal.Column_Naming_Helper.Column_Naming_Helper
 import Standard.Table.Internal.Constant_Column.Constant_Column
 import Standard.Table.Internal.Problem_Builder.Problem_Builder
+import Standard.Table.Internal.Replace_Helpers
 import Standard.Table.Internal.Table_Helpers
 import Standard.Table.Internal.Table_Helpers.Table_Column_Helper
 import Standard.Table.Internal.Unique_Name_Strategy.Unique_Name_Strategy
@@ -926,6 +927,54 @@ type Table
         on_problems.attach_problems_before problems <|
             Warning.set result []
 
+    ## PRIVATE
+       A helper that creates a two-column literal table from a `Map`.
+    make_table_from_map : Map Any Any -> Text -> Text -> Table
+    make_table_from_map self map key_column_name value_column_name =
+        total_size = map.size * 2
+
+        if map.is_empty then Error.throw (Illegal_Argument.Error "Map argument cannot be empty") else
+            if total_size > MAX_LITERAL_ELEMENT_COUNT then Error.throw (Illegal_Argument.Error "Map argument is too large ("+map.size.to_text+" entries): materialize a table into the database instead") else
+                keys_and_values = map.to_vector
+                self.make_table_from_vectors [keys_and_values.map .first, keys_and_values.map .second] [key_column_name, value_column_name]
+
+    ## PRIVATE
+       A helper that creates a literal table from `Vector`s.
+    make_table_from_vectors : Vector (Vector Any) -> Vector Text -> Table
+    make_table_from_vectors self column_vectors column_names =
+        Runtime.assert (column_vectors.length == column_names.length) "Vectors and column names must have the same length"
+
+        # Assume the columns are all the same length; if not, it will be an error anyway.
+        total_size = if column_vectors.is_empty || column_vectors.at 0 . is_empty then 0 else
+            column_vectors.length * (column_vectors.at 0 . length)
+
+        if total_size == 0 then Error.throw (Illegal_Argument.Error "Vectors cannot be empty") else
+            if total_size > MAX_LITERAL_ELEMENT_COUNT then Error.throw (Illegal_Argument.Error "Too many elements for table literal ("+total_size.to_text+"): materialize a table into the database instead") else
+                type_mapping = self.connection.dialect.get_type_mapping
+
+                values_to_type_ref column_vector =
+                    value_type = Value_Type_Helpers.find_common_type_for_arguments column_vector
+                    sql_type = case value_type of
+                        Nothing -> SQL_Type.null
+                        _ -> type_mapping.value_type_to_sql value_type Problem_Behavior.Ignore
+                    SQL_Type_Reference.from_constant sql_type
+
+                literal_table_name = self.connection.base_connection.table_naming_helper.generate_random_table_name "enso-literal-"
+
+                from_spec = From_Spec.Literal_Values column_vectors column_names literal_table_name
+                context = Context.for_subquery from_spec
+
+                internal_columns = 0.up_to column_vectors.length . map i->
+                    column_vector = column_vectors.at i
+                    column_name = column_names.at i
+
+                    type_ref = values_to_type_ref column_vector.to_vector
+                    generated_literal_column_name = "column"+(i+1).to_text
+                    sql_expression = SQL_Expression.Column literal_table_name generated_literal_column_name
+                    Internal_Column.Value column_name type_ref sql_expression
+
+                Table.Value literal_table_name self.connection internal_columns context
+
     ## PRIVATE
 
        Create a constant column from a value.
@@ -1392,7 +1441,7 @@ type Table
          In the Database backend, there are no guarantees related to ordering of
          results.
 
-       ? Error Conditions
+       ! Error Conditions
 
          - If this table or the lookup table is lacking any of the columns
            specified in `key_columns`, a `Missing_Input_Columns` error is raised.
@@ -1403,7 +1452,7 @@ type Table
          - If a column that is being updated from the lookup table has a type
            that is not compatible with the type of the corresponding column in
            this table, a `No_Common_Type` error is raised.
-         - If a key column contains `Nothing` values, either in the lookup table,
+         - If a key column contains `Nothing` values in the lookup table,
            a `Null_Values_In_Key_Columns` error is raised.
          - If `allow_unmatched_rows` is `False` and there are rows in this table
            that do not have a matching row in the lookup table, an
@@ -1420,6 +1469,87 @@ type Table
         Helpers.ensure_same_connection "table" [self, lookup_table] <|
             Lookup_Query_Helper.build_lookup_query self lookup_table key_columns add_new_columns allow_unmatched_rows on_problems
 
+    ## ALIAS find replace
+       GROUP Standard.Base.Calculations
+       ICON join
+       Replaces values in `column` using `lookup_table` to specify a
+       mapping from old to new values.
+
+       Arguments:
+       - lookup_table: the table to use as a mapping from old to new values. A
+         `Map` can also be used here (in which case passing `from_column` or
+         `to_column` is disallowed and will throw an `Illegal_Argument` error.
+       - column: the column within `self` to perform the replace on.
+       - from_column: the column within `lookup_table` to match against `column`
+         in `self`.
+       - to_column: the column within `lookup_table` to get new values from.
+       - allow_unmatched_rows: Specifies how to handle missing rows in the lookup.
+         If `False` (the default), an `Unmatched_Rows_In_Lookup` error is raised.
+         If `True`, the unmatched rows are left unchanged. Any new columns will
+         be filled with `Nothing`.
+       - on_problems: Specifies how to handle problems if they occur, reporting
+         them as warnings by default.
+
+       ? Result Ordering
+
+         When operating in-memory, this operation preserves the order of rows
+         from this table (unlike `join`).
+         In the Database backend, there are no guarantees related to ordering of
+         results.
+
+       ! Error Conditions
+
+         - If this table or the lookup table is lacking any of the columns
+           specified by `from_column`, `to_column`, or `column`, a
+           `Missing_Input_Columns` error is raised.
+         - If a single row is matched by multiple entries in the lookup table,
+           a `Non_Unique_Key` error is raised.
+         - If a column that is being updated from the lookup table has a type
+           that is not compatible with the type of the corresponding column in
+           this table, a `No_Common_Type` error is raised.
+         - If a key column contains `Nothing` values in the lookup table,
+           a `Null_Values_In_Key_Columns` error is raised.
+         - If `allow_unmatched_rows` is `False` and there are rows in this table
+           that do not have a matching row in the lookup table, an
+           `Unmatched_Rows_In_Lookup` error is raised.
+         - The following problems may be reported according to the `on_problems`
+           setting:
+           - If any of the `columns` is a floating-point type,
+             a `Floating_Point_Equality`.
+
+       > Example
+         Replace values in column 'x' using a lookup table.
+
+             table = Table.new [['x', [1, 2, 3, 4]], ['y', ['a', 'b', 'c', 'd']], ['z', ['e', 'f', 'g', 'h']]]
+             #      | x | y | z
+             #   ---+---+---+---
+             #    0 | 1 | a | e
+             #    1 | 2 | b | f
+             #    2 | 3 | c | g
+             #    3 | 4 | d | h
+
+             lookup_table = Table.new [['x', [1, 2, 3, 4]], ['new_x', [10, 20, 30, 40]]]
+             #      | old_x | new_x
+             #   ---+-------+-------
+             #    0 | 1     | 10
+             #    1 | 2     | 20
+             #    2 | 3     | 30
+             #    3 | 4     | 40
+
+             result = table.replace lookup_table 'x'
+             #      | x  | y | z
+             #   ---+----+---+---
+             #    0 | 10 | a | e
+             #    1 | 20 | b | f
+             #    2 | 30 | c | g
+             #    3 | 40 | d | h
+    @column Widget_Helpers.make_column_name_selector
+    @from_column Widget_Helpers.make_column_name_selector
+    @to_column Widget_Helpers.make_column_name_selector
+    replace : Table | Map -> (Text | Integer) -> (Text | Integer | Nothing) -> (Text | Integer | Nothing) -> Boolean -> Problem_Behavior -> Table ! Missing_Input_Columns | Non_Unique_Key | Unmatched_Rows_In_Lookup
+    replace self lookup_table:(Table | Map) column:(Text | Integer) from_column:(Text | Integer | Nothing)=Nothing to_column:(Text | Integer | Nothing)=Nothing allow_unmatched_rows:Boolean=True on_problems:Problem_Behavior=Problem_Behavior.Report_Warning =
+        Replace_Helpers.replace self lookup_table column from_column to_column allow_unmatched_rows on_problems
+
     ## ALIAS join by row position
        GROUP Standard.Base.Calculations
        ICON dataframes_join
@@ -2706,3 +2836,7 @@ Table.from (that:Materialized_Table) =
 
 ## PRIVATE
 Table_Ref.from (that:Table) = Table_Ref.Value that
+
+## PRIVATE
+    The largest dataset that can be used to make a literal table, expressed in number of elements.
+MAX_LITERAL_ELEMENT_COUNT = 256

distribution/lib/Standard/Database/0.0.0-dev/src/Internal/Base_Generator.enso

@@ -341,6 +341,10 @@ generate_from_part dialect from_spec = case from_spec of
         dialect.wrap_identifier name ++ alias dialect as_name
     From_Spec.Query raw_sql as_name ->
         Builder.code raw_sql . paren ++ alias dialect as_name
+    From_Spec.Literal_Values vecs column_names as_name ->
+        Runtime.assert (vecs.length == column_names.length) "Vectors and column names must have the same length"
+        values = Builder.join ", " (vecs.transpose.map (vec-> Builder.join ", " (vec.map Builder.interpolation) . paren))
+        Builder.code "(VALUES " ++ values ++ ")" ++ alias dialect as_name
     From_Spec.Join kind left_spec right_spec on ->
         left = generate_from_part dialect left_spec
         right = generate_from_part dialect right_spec

distribution/lib/Standard/Database/0.0.0-dev/src/Internal/IR/From_Spec.enso

@@ -38,6 +38,17 @@ type From_Spec
          the same table.
     Query (raw_sql : Text) (alias : Text)
 
+    ## PRIVATE
+
+       A query source consisting of a literal VALUES clause.
+
+       Arguments:
+       - column_vectors: the contents of the literal table's columns.
+       - column_names: the names of the literal table's columns,
+       - alias: the name by which the table can be referred to in other parts of
+         the query.
+    Literal_Values (column_vectors : Vector (Vector Any)) (column_names : Vector Text) (alias : Text)
+
     ## PRIVATE
 
        A query source that performs a join operation on two sources.