/// Hold all available objects in stack.

std::mutex mutex;

std::stack<std::unique_ptr<T>> stack;

/// Specialized deleter for std::unique_ptr.

/// Returns underlying pointer back to stack thus reclaiming its ownership.

struct Deleter {

SimpleObjectPool<T>* parent;

Deleter(SimpleObjectPool<T>* parent_ = nullptr) : parent {parent_} {} /// NOLINT

void operator()(T* owning_ptr) const {

std::lock_guard lock {parent->mutex};

parent->stack.emplace(owning_ptr);

}

};

using Pointer = std::unique_ptr<T, Deleter>;

/// Extracts and returns a pointer from the stack if it's not empty,

/// creates a new one by calling provided f() otherwise.

template <typename Factory>

Pointer get(Factory&& f) {

std::unique_lock lock(mutex);

if (stack.empty()) {

return {f(), this};

}

auto object = stack.top().release();

stack.pop();

return std::unique_ptr<T, Deleter>(object, Deleter(this));

}

/// Like get(), but creates object using default constructor.

Pointer getDefault() {

return get([] { return new T; });

}

FieldVisitorReplaceScalars(const Field& replacement_, size_t num_dimensions_to_keep_)

: replacement(replacement_), num_dimensions_to_keep(num_dimensions_to_keep_) {}

template <typename T>

Field operator()(const T& x) const {

if constexpr (std::is_same_v<T, Array>) {

if (num_dimensions_to_keep == 0) {

return replacement;

}

const size_t size = x.size();

Array res(size);

for (size_t i = 0; i < size; ++i) {

res[i] = apply_visitor(

FieldVisitorReplaceScalars(replacement, num_dimensions_to_keep - 1), x[i]);

}

return res;

} else {

return replacement;

}

}

const Field& replacement;

size_t num_dimensions_to_keep;

JSONDataParser<ParserImpl>* parser, const ParseConfig& config) {

auto& column_object = assert_cast<ColumnObject&>(column);

std::optional<ParseResult> result;

/// Treat empty string as an empty object

/// for better CAST from String to Object.

if (length > 0) {

result = parser->parse(src, length, config);

} else {

result = ParseResult {};

}

if (!result) {

VLOG_DEBUG << "failed to parse " << std::string_view(src, length) << ", length= " << length;

if (config::variant_throw_exeception_on_invalid_json) {

throw doris::Exception(ErrorCode::INVALID_ARGUMENT, "Failed to parse object {}",

std::string_view(src, length));

}

// Treat as string

PathInData root_path;

Field field(String(src, length));

result = ParseResult {{root_path}, {field}};

}

auto& [paths, values] = *result;

assert(paths.size() == values.size());

size_t old_num_rows = column_object.size();

for (size_t i = 0; i < paths.size(); ++i) {

FieldInfo field_info;

get_field_info(values[i], &field_info);

if (WhichDataType(field_info.scalar_type_id).is_nothing()) {

continue;

}

if (column_object.get_subcolumn(paths[i], i) == nullptr) {

if (paths[i].has_nested_part()) {

column_object.add_nested_subcolumn(paths[i], field_info, old_num_rows);

} else {

column_object.add_sub_column(paths[i], old_num_rows);

}

}

auto* subcolumn = column_object.get_subcolumn(paths[i], i);

if (!subcolumn) {

throw doris::Exception(ErrorCode::INVALID_ARGUMENT, "Failed to find sub column {}",

paths[i].get_path());

}

if (subcolumn->size() != old_num_rows) {

throw doris::Exception(ErrorCode::INVALID_ARGUMENT,

"subcolumn {} size missmatched, may contains duplicated entry",

paths[i].get_path());

}

subcolumn->insert(std::move(values[i]), std::move(field_info));

}

// /// Insert default values to missed subcolumns.

const auto& subcolumns = column_object.get_subcolumns();

for (const auto& entry : subcolumns) {

if (entry->data.size() == old_num_rows) {

bool inserted = column_object.try_insert_default_from_nested(entry);

if (!inserted) {

entry->data.insert_default();

}

}

}

column_object.incr_num_rows();

const ParseConfig& config) {

auto parser = parsers_pool.get([] { return new JsonParser(); });

for (size_t i = 0; i < raw_json_column.size(); ++i) {

StringRef raw_json = raw_json_column.get_data_at(i);

parse_json_to_variant(column, raw_json.data, raw_json.size, parser.get(), config);

}