xy720 commented on code in PR #17330:
URL: https://github.com/apache/doris/pull/17330#discussion_r1124028196


##########
be/src/vec/columns/column_map.cpp:
##########
@@ -25,50 +25,108 @@ namespace doris::vectorized {
 /** A column of map values.
   */
 std::string ColumnMap::get_name() const {
-    return "Map(" + keys->get_name() + ", " + values->get_name() + ")";
+    return "Map(" + keys_column->get_name() + ", " + values_column->get_name() 
+ ")";
 }
 
-ColumnMap::ColumnMap(MutableColumnPtr&& keys, MutableColumnPtr&& values)
-        : keys(std::move(keys)), values(std::move(values)) {
-    check_size();
-}
+ColumnMap::ColumnMap(MutableColumnPtr&& keys, MutableColumnPtr&& values, 
MutableColumnPtr&& offsets)
+        : keys_column(std::move(keys)),
+          values_column(std::move(values)),
+          offsets_column(std::move(offsets)) {
+    const COffsets* offsets_concrete = typeid_cast<const 
COffsets*>(offsets_column.get());
 
-ColumnArray::Offsets64& ColumnMap::get_offsets() const {
-    const ColumnArray& column_keys = assert_cast<const 
ColumnArray&>(get_keys());
-    // todo . did here check size ?
-    return const_cast<Offsets64&>(column_keys.get_offsets());
-}
+    if (!offsets_concrete) {
+        LOG(FATAL) << "offsets_column must be a ColumnUInt64";
+    }
 
-void ColumnMap::check_size() const {
-    const auto* key_array = typeid_cast<const ColumnArray*>(keys.get());
-    const auto* value_array = typeid_cast<const ColumnArray*>(values.get());
-    CHECK(key_array) << "ColumnMap keys can be created only from array";
-    CHECK(value_array) << "ColumnMap values can be created only from array";
-    CHECK_EQ(get_keys_ptr()->size(), get_values_ptr()->size());
+    if (!offsets_concrete->empty() && keys && values) {
+        auto last_offset = offsets_concrete->get_data().back();
+
+        /// This will also prevent possible overflow in offset.
+        if (keys_column->size() != last_offset) {
+            LOG(FATAL) << "offsets_column has data inconsistent with 
key_column";
+        }
+        if (values_column->size() != last_offset) {
+            LOG(FATAL) << "offsets_column has data inconsistent with 
value_column";
+        }
+    }
 }
 
 // todo. here to resize every row map
 MutableColumnPtr ColumnMap::clone_resized(size_t to_size) const {
-    auto res = ColumnMap::create(keys->clone_resized(to_size), 
values->clone_resized(to_size));
+    auto res = ColumnMap::create(get_keys().clone_empty(), 
get_values().clone_empty(),
+                                 COffsets::create());
+    if (to_size == 0) {
+        return res;
+    }
+
+    size_t from_size = size();
+
+    if (to_size <= from_size) {
+        res->get_offsets().assign(get_offsets().begin(), get_offsets().begin() 
+ to_size);
+        res->get_keys().insert_range_from(get_keys(), 0, get_offsets()[to_size 
- 1]);
+        res->get_values().insert_range_from(get_values(), 0, 
get_offsets()[to_size - 1]);
+    } else {
+        /// Copy column and append empty arrays for extra elements.
+        Offset64 offset = 0;
+        if (from_size > 0) {
+            res->get_offsets().assign(get_offsets().begin(), 
get_offsets().end());
+            res->get_keys().insert_range_from(get_keys(), 0, 
get_keys().size());
+            res->get_values().insert_range_from(get_values(), 0, 
get_values().size());
+            offset = get_offsets().back();
+        }
+        res->get_offsets().resize(to_size);
+        for (size_t i = from_size; i < to_size; ++i) {
+            res->get_offsets()[i] = offset;
+        }
+    }
     return res;
 }
 
 // to support field functions
 Field ColumnMap::operator[](size_t n) const {
-    // Map is FieldVector , see in field.h
-    Map res(2);
-    keys->get(n, res[0]);
-    values->get(n, res[1]);
+    // Map is FieldVector, now we keep key value in seperate  , see in field.h
+    Map m(2);
+    size_t start_offset = offset_at(n);
+    size_t element_size = size_at(n);
+
+    if (element_size > max_array_size_as_field) {
+        LOG(FATAL) << "element size " << start_offset
+                   << " is too large to be manipulated as single map field,"
+                   << "maximum size " << max_array_size_as_field;
+    }
 
-    return res;
+    Array k(element_size), v(element_size);

Review Comment:
   Already keep up with map literal, that's ok.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org

Reply via email to