Remove unneeded computed_data

Author: alexowens90

cpp/arcticdb/processing/clause.cpp

@@ -149,9 +149,8 @@ OutputSchema FilterClause::modify_schema(OutputSchema&& output_schema) const {
     for (const auto& field: output_schema.stream_descriptor_.fields()) {
         column_types.emplace(field.name(), field.type().data_type());
     }
-    std::unordered_map<std::string, std::optional<DataType>> computed_data;
     auto expr = expression_context_->expression_nodes_.get_value(expression_context_->root_node_name_.value);
-    auto opt_datatype = expr->compute(*expression_context_, column_types, computed_data);
+    auto opt_datatype = expr->compute(*expression_context_, column_types);
     user_input::check<ErrorCode::E_INVALID_USER_ARGUMENT>(!opt_datatype.has_value(), "FilterClause AST produces a column, not a bitset");
     return output_schema;
 }
@@ -208,9 +207,8 @@ OutputSchema ProjectClause::modify_schema(OutputSchema&& output_schema) const {
     for (const auto& field: output_schema.stream_descriptor_.fields()) {
         column_types.emplace(field.name(), field.type().data_type());
     }
-    std::unordered_map<std::string, std::optional<DataType>> computed_data;
     auto expr = expression_context_->expression_nodes_.get_value(expression_context_->root_node_name_.value);
-    auto opt_datatype = expr->compute(*expression_context_, column_types, computed_data);
+    auto opt_datatype = expr->compute(*expression_context_, column_types);
     user_input::check<ErrorCode::E_INVALID_USER_ARGUMENT>(opt_datatype.has_value(), "ProjectClause AST produces a bitset, not a column");
     output_schema.stream_descriptor_.add_scalar_field(*opt_datatype, output_column_);
     return output_schema;

cpp/arcticdb/processing/expression_node.cpp

@@ -71,8 +71,7 @@ VariantData ExpressionNode::compute(ProcessingUnit& seg) const {
 }
 
 std::optional<DataType> ExpressionNode::compute(ExpressionContext& expression_context,
-                                                const std::unordered_map<std::string, DataType>& column_types,
-                                                std::unordered_map<std::string, std::optional<DataType>>& computed_data) const {
+                                                const std::unordered_map<std::string, DataType>& column_types) const {
     std::optional<DataType> res;
     std::optional<DataType> left_type = util::variant_match(
             left_,
@@ -86,15 +85,9 @@ std::optional<DataType> ExpressionNode::compute(ExpressionContext& expression_co
             [&expression_context] (const ValueName& value_name) -> std::optional<DataType> {
                 return expression_context.values_.get_value(value_name.value)->data_type_;
             },
-            [&expression_context, &column_types, &computed_data] (const ExpressionName& expression_name) -> std::optional<DataType> {
-                if (auto it = computed_data.find(expression_name.value); it != std::end(computed_data)) {
-                    return it->second;
-                } else {
-                    auto expr = expression_context.expression_nodes_.get_value(expression_name.value);
-                    auto res = expr->compute(expression_context, column_types, computed_data);
-                    computed_data.try_emplace(expression_name.value, res);
-                    return res;
-                }
+            [&expression_context, &column_types] (const ExpressionName& expression_name) -> std::optional<DataType> {
+                auto expr = expression_context.expression_nodes_.get_value(expression_name.value);
+                return expr->compute(expression_context, column_types);
             },
             [] (auto&&) -> std::optional<DataType> {
                 internal::raise<ErrorCode::E_ASSERTION_FAILURE>("Unexpected expression argument type");
@@ -161,15 +154,9 @@ std::optional<DataType> ExpressionNode::compute(ExpressionContext& expression_co
                     empty_value_set = value_set->empty();
                     return value_set->base_type().data_type();
                 },
-                [&expression_context, &column_types, &computed_data] (const ExpressionName& expression_name) -> std::optional<DataType> {
-                    if (auto it = computed_data.find(expression_name.value); it != std::end(computed_data)) {
-                        return it->second;
-                    } else {
+                [&expression_context, &column_types] (const ExpressionName& expression_name) -> std::optional<DataType> {
                         auto expr = expression_context.expression_nodes_.get_value(expression_name.value);
-                        auto res = expr->compute(expression_context, column_types, computed_data);
-                        computed_data.try_emplace(expression_name.value, res);
-                        return res;
-                    }
+                        return expr->compute(expression_context, column_types);
                 },
                 [] (auto&&) -> std::optional<DataType> {
                     internal::raise<ErrorCode::E_ASSERTION_FAILURE>("Unexpected expression argument type");

cpp/arcticdb/processing/expression_node.hpp

@@ -92,8 +92,7 @@ struct ExpressionNode {
     // TODO: better return type
     // TODO: Make expression_context const
     std::optional<DataType> compute(ExpressionContext& expression_context,
-                                    const std::unordered_map<std::string, DataType>& column_types,
-                                    std::unordered_map<std::string, std::optional<DataType>>& computed_data) const;
+                                    const std::unordered_map<std::string, DataType>& column_types) const;
 };
 
 } //namespace arcticdb