NULLABLE = 0,

NOT_NULL,

FOLLOW_INPUT,

struct FunctionJsonbParseState {

JsonbParser default_value_parser;

bool has_const_default_value = false;

};

static constexpr auto name = "json_parse";

static constexpr auto alias = "jsonb_parse";

static FunctionPtr create() { return std::make_shared<FunctionJsonbParseBase>(); }

String get_name() const override {

String nullable;

switch (nullable_mode) {

case NullalbeMode::NULLABLE:

nullable = "_nullable";

break;

case NullalbeMode::NOT_NULL:

nullable = "_notnull";

break;

case NullalbeMode::FOLLOW_INPUT:

nullable = "";

break;

}

String error_mode;

switch (parse_error_handle_mode) {

case JsonbParseErrorMode::FAIL:

break;

case JsonbParseErrorMode::RETURN_NULL:

error_mode = "_error_to_null";

break;

case JsonbParseErrorMode::RETURN_VALUE:

error_mode = "_error_to_value";

break;

case JsonbParseErrorMode::RETURN_INVALID:

error_mode = "_error_to_invalid";

break;

}

return name + nullable + error_mode;

}

size_t get_number_of_arguments() const override {

switch (parse_error_handle_mode) {

case JsonbParseErrorMode::FAIL:

return 1;

case JsonbParseErrorMode::RETURN_NULL:

return 1;

case JsonbParseErrorMode::RETURN_VALUE:

return 2;

case JsonbParseErrorMode::RETURN_INVALID:

return 1;

}

}

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

bool is_nullable = true;

switch (nullable_mode) {

case NullalbeMode::NULLABLE:

is_nullable = true;

break;

case NullalbeMode::NOT_NULL:

is_nullable = false;

break;

case NullalbeMode::FOLLOW_INPUT:

is_nullable = arguments[0]->is_nullable();

break;

}

return is_nullable ? make_nullable(std::make_shared<DataTypeJsonb>())

: std::make_shared<DataTypeJsonb>();

}

bool use_default_implementation_for_nulls() const override { return false; }

Status open(FunctionContext* context, FunctionContext::FunctionStateScope scope) override {

if (scope == FunctionContext::FunctionStateScope::FRAGMENT_LOCAL) {

std::shared_ptr<FunctionJsonbParseState> state =

std::make_shared<FunctionJsonbParseState>();

context->set_function_state(FunctionContext::FRAGMENT_LOCAL, state);

}

if constexpr (parse_error_handle_mode == JsonbParseErrorMode::RETURN_VALUE) {

if (context->is_col_constant(1)) {

const auto default_value_col = context->get_constant_col(1)->column_ptr;

const auto& default_value = default_value_col->get_data_at(0);

JsonbErrType error = JsonbErrType::E_NONE;

if (scope == FunctionContext::FunctionStateScope::FRAGMENT_LOCAL) {

auto* state = reinterpret_cast<FunctionJsonbParseState*>(

context->get_function_state(FunctionContext::FRAGMENT_LOCAL));

if (!state->default_value_parser.parse(

default_value.data,

static_cast<unsigned int>(default_value.size))) {

error = state->default_value_parser.getErrorCode();

return Status::InvalidArgument(

"invalid default json value: {} , error: {}",

std::string_view(default_value.data, default_value.size),

JsonbErrMsg::getErrMsg(error));

}

state->has_const_default_value = true;

}

}

}

return Status::OK();

}

Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,

uint32_t result, size_t input_rows_count) const override {

const IColumn& col_from = *(block.get_by_position(arguments[0]).column);

auto null_map = ColumnUInt8::create(0, 0);

bool is_nullable = false;

switch (nullable_mode) {

case NullalbeMode::NULLABLE: {

is_nullable = true;

null_map = ColumnUInt8::create(input_rows_count, 0);

break;

}

case NullalbeMode::NOT_NULL:

is_nullable = false;

break;

case NullalbeMode::FOLLOW_INPUT: {

auto argument_column = col_from.convert_to_full_column_if_const();

if (auto* nullable = check_and_get_column<ColumnNullable>(*argument_column)) {

is_nullable = true;

null_map = ColumnUInt8::create(input_rows_count, 0);

// Danger: Here must dispose the null map data first! Because

// argument_columns[i]=nullable->get_nested_column_ptr(); will release the mem

// of column nullable mem of null map

VectorizedUtils::update_null_map(null_map->get_data(),

nullable->get_null_map_data());

argument_column = nullable->get_nested_column_ptr();

}

break;

}

}

// const auto& col_with_type_and_name = block.get_by_position(arguments[0]);

// const IColumn& col_from = *col_with_type_and_name.column;

const ColumnString* col_from_string = check_and_get_column<ColumnString>(col_from);

if (auto* nullable = check_and_get_column<ColumnNullable>(col_from)) {

col_from_string =

check_and_get_column<ColumnString>(*nullable->get_nested_column_ptr());

}

if (!col_from_string) {

return Status::RuntimeError("Illegal column {} should be ColumnString",

col_from.get_name());

}

auto col_to = ColumnString::create();

//IColumn & col_to = *res;

size_t size = col_from.size();

col_to->reserve(size);

// parser can be reused for performance

JsonbParser parser;

JsonbErrType error = JsonbErrType::E_NONE;

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

if (col_from.is_null_at(i)) {

null_map->get_data()[i] = 1;

col_to->insert_data("", 0);

continue;

}

const auto& val = col_from_string->get_data_at(i);

if (parser.parse(val.data, static_cast<unsigned int>(val.size))) {

// insert jsonb format data

col_to->insert_data(parser.getWriter().getOutput()->getBuffer(),

(size_t)parser.getWriter().getOutput()->getSize());

} else {

error = parser.getErrorCode();

switch (parse_error_handle_mode) {

case JsonbParseErrorMode::FAIL:

return Status::InvalidArgument("json parse error: {} for value: {}",

JsonbErrMsg::getErrMsg(error),

std::string_view(val.data, val.size));

case JsonbParseErrorMode::RETURN_NULL: {

if (is_nullable) {

null_map->get_data()[i] = 1;

}

col_to->insert_data("", 0);

continue;

}

case JsonbParseErrorMode::RETURN_VALUE: {

FunctionJsonbParseState* state = reinterpret_cast<FunctionJsonbParseState*>(

context->get_function_state(FunctionContext::FRAGMENT_LOCAL));

if (state->has_const_default_value) {

col_to->insert_data(

state->default_value_parser.getWriter().getOutput()->getBuffer(),

(size_t)state->default_value_parser.getWriter()

.getOutput()

->getSize());

} else {

auto value = block.get_by_position(arguments[1]).column->get_data_at(i);

if (parser.parse(value.data, static_cast<unsigned int>(value.size))) {

// insert jsonb format data

col_to->insert_data(parser.getWriter().getOutput()->getBuffer(),

(size_t)parser.getWriter().getOutput()->getSize());

} else {

return Status::InvalidArgument(

"json parse error: {} for default value: {}",

JsonbErrMsg::getErrMsg(error),

std::string_view(value.data, value.size));

}

}

continue;

}

case JsonbParseErrorMode::RETURN_INVALID:

col_to->insert_data("", 0);

continue;

}

}

}

if (is_nullable) {

block.replace_by_position(

result, ColumnNullable::create(std::move(col_to), std::move(null_map)));

} else {

block.replace_by_position(result, std::move(col_to));

}

return Status::OK();

}

static constexpr auto name = Impl::name;

static constexpr auto alias = Impl::alias;

static FunctionPtr create() { return std::make_shared<FunctionJsonbExtract>(); }

String get_name() const override { return name; }

bool is_variadic() const override { return true; }

size_t get_number_of_arguments() const override { return 0; }

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

return make_nullable(std::make_shared<typename Impl::ReturnType>());

}

DataTypes get_variadic_argument_types_impl() const override {

if constexpr (vectorized::HasGetVariadicArgumentTypesImpl<Impl>) {

return Impl::get_variadic_argument_types_impl();

} else {

return {};

}

}

Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,

uint32_t result, size_t input_rows_count) const override {

DCHECK_GE(arguments.size(), 2);

ColumnPtr jsonb_data_column;

bool jsonb_data_const = false;

// prepare jsonb data column

std::tie(jsonb_data_column, jsonb_data_const) =

unpack_if_const(block.get_by_position(arguments[0]).column);

const auto& ldata = assert_cast<const ColumnString*>(jsonb_data_column.get())->get_chars();

const auto& loffsets =

assert_cast<const ColumnString*>(jsonb_data_column.get())->get_offsets();

// prepare parse path column prepare

std::vector<const ColumnString*> jsonb_path_columns;

std::vector<bool> path_const(arguments.size() - 1);

for (int i = 0; i < arguments.size() - 1; ++i) {

ColumnPtr path_column;

bool is_const = false;

std::tie(path_column, is_const) =

unpack_if_const(block.get_by_position(arguments[i + 1]).column);

path_const[i] = is_const;

jsonb_path_columns.push_back(assert_cast<const ColumnString*>(path_column.get()));

}

auto null_map = ColumnUInt8::create(input_rows_count, 0);

auto res = Impl::ColumnType::create();

bool is_invalid_json_path = false;

// execute Impl

if constexpr (std::is_same_v<typename Impl::ReturnType, DataTypeString> ||

std::is_same_v<typename Impl::ReturnType, DataTypeJsonb>) {

auto& res_data = res->get_chars();

auto& res_offsets = res->get_offsets();

Status st = Impl::vector_vector_v2(

context, ldata, loffsets, jsonb_data_const, jsonb_path_columns, path_const,

res_data, res_offsets, null_map->get_data(), is_invalid_json_path);

if (!st.ok()) {

return st;

}

} else {

// not support other extract type for now (e.g. int, double, ...)

DCHECK_EQ(jsonb_path_columns.size(), 1);

const auto& rdata = jsonb_path_columns[0]->get_chars();

const auto& roffsets = jsonb_path_columns[0]->get_offsets();

if (jsonb_data_const) {

Impl::scalar_vector(context, jsonb_data_column->get_data_at(0), rdata, roffsets,

res->get_data(), null_map->get_data(), is_invalid_json_path);

} else if (path_const[0]) {

Impl::vector_scalar(context, ldata, loffsets, jsonb_path_columns[0]->get_data_at(0),

res->get_data(), null_map->get_data(), is_invalid_json_path);

} else {

Impl::vector_vector(context, ldata, loffsets, rdata, roffsets, res->get_data(),

null_map->get_data(), is_invalid_json_path);

}

if (is_invalid_json_path) {

return Status::InvalidArgument(

"Json path error: {} for value: {}",

JsonbErrMsg::getErrMsg(JsonbErrType::E_INVALID_JSON_PATH),

std::string_view(reinterpret_cast<const char*>(rdata.data()),

rdata.size()));

}

}

block.get_by_position(result).column =

ColumnNullable::create(std::move(res), std::move(null_map));

return Status::OK();

}

static constexpr auto name = "json_keys";

static constexpr auto alias = "jsonb_keys";

static FunctionPtr create() { return std::make_shared<FunctionJsonbKeys>(); }

String get_name() const override { return name; }

bool is_variadic() const override { return true; }

size_t get_number_of_arguments() const override { return 0; }

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

return make_nullable(

std::make_shared<DataTypeArray>(make_nullable(std::make_shared<DataTypeString>())));

}

Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,

uint32_t result, size_t input_rows_count) const override {

DCHECK_GE(arguments.size(), 1);

if (arguments.size() != 1 && arguments.size() != 2) {

// here has argument param error

return Status::InvalidArgument("json_keys should have 1 or 2 arguments");

}

ColumnPtr jsonb_data_column = nullptr;

const NullMap* data_null_map = nullptr;

// prepare jsonb data column

jsonb_data_column = unpack_if_const(block.get_by_position(arguments[0]).column).first;

if (block.get_by_position(arguments[0]).column->is_nullable()) {

const auto* nullable = check_and_get_column<ColumnNullable>(jsonb_data_column.get());

jsonb_data_column = nullable->get_nested_column_ptr();

data_null_map = &nullable->get_null_map_data();

}

const ColumnString* col_from_string =

check_and_get_column<ColumnString>(jsonb_data_column.get());

// prepare parse path column prepare, maybe we do not have path column

ColumnPtr jsonb_path_column = nullptr;

const ColumnString* jsonb_path_col = nullptr;

bool path_const = false;

const NullMap* path_null_map = nullptr;

if (arguments.size() == 2) {

// we have should have a ColumnString for path

std::tie(jsonb_path_column, path_const) =

unpack_if_const(block.get_by_position(arguments[1]).column);

if (block.get_by_position(arguments[1]).column->is_nullable()) {

const auto* nullable =

check_and_get_column<ColumnNullable>(jsonb_path_column.get());

jsonb_path_column = nullable->get_nested_column_ptr();

path_null_map = &nullable->get_null_map_data();

}

jsonb_path_col = check_and_get_column<ColumnString>(jsonb_path_column.get());

}

auto null_map = ColumnUInt8::create(input_rows_count, 0);

NullMap& res_null_map = null_map->get_data();

auto dst_arr = ColumnArray::create(

ColumnNullable::create(ColumnString::create(), ColumnUInt8::create()),

ColumnArray::ColumnOffsets::create());

ColumnNullable& dst_nested_column = assert_cast<ColumnNullable&>(dst_arr->get_data());

Status st;

if (jsonb_path_column) {

if (path_const) {

st = inner_loop_impl<true, true>(input_rows_count, *dst_arr, dst_nested_column,

res_null_map, *col_from_string, data_null_map,

jsonb_path_col, path_null_map);

} else {

st = inner_loop_impl<true, false>(input_rows_count, *dst_arr, dst_nested_column,

res_null_map, *col_from_string, data_null_map,

jsonb_path_col, path_null_map);

}

} else {

st = inner_loop_impl<false, false>(input_rows_count, *dst_arr, dst_nested_column,

res_null_map, *col_from_string, data_null_map,

jsonb_path_col, path_null_map);

}

if (!st.ok()) {

return st;

}

block.get_by_position(result).column =

ColumnNullable::create(std::move(dst_arr), std::move(null_map));

return st;

}

template <bool JSONB_PATH_PARAM, bool JSON_PATH_CONST>

static ALWAYS_INLINE Status inner_loop_impl(size_t input_rows_count, ColumnArray& dst_arr,

ColumnNullable& dst_nested_column,

NullMap& res_null_map,

const ColumnString& col_from_string,

const NullMap* jsonb_data_nullmap,

const ColumnString* jsonb_path_column,

const NullMap* path_null_map) {

// if path is const, we just need to parse it once

JsonbPath const_path;

if constexpr (JSONB_PATH_PARAM && JSON_PATH_CONST) {

StringRef r_raw_ref = jsonb_path_column->get_data_at(0);

if (!const_path.seek(r_raw_ref.data, r_raw_ref.size)) {

return Status::InvalidArgument(

"Json path error: {} for value: {}",

JsonbErrMsg::getErrMsg(JsonbErrType::E_INVALID_JSON_PATH),

r_raw_ref.to_string());

}

}

const auto& ldata = col_from_string.get_chars();

const auto& loffsets = col_from_string.get_offsets();

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

// if jsonb data is null or path column is null , we should return null

if (jsonb_data_nullmap && (&jsonb_data_nullmap)[i]) {

res_null_map[i] = 1;

dst_arr.insert_default();

continue;

}

if constexpr (JSONB_PATH_PARAM && !JSON_PATH_CONST) {

if (path_null_map && (&path_null_map)[i]) {

res_null_map[i] = 1;

dst_arr.insert_default();

continue;

}

}

// extract jsonb keys

size_t l_off = loffsets[i - 1];

size_t l_size = loffsets[i] - l_off;

if (l_size == 0) {

res_null_map[i] = 1;

dst_arr.insert_default();

continue;

}

const char* l_raw = reinterpret_cast<const char*>(&ldata[l_off]);

JsonbDocument* doc = JsonbDocument::checkAndCreateDocument(l_raw, l_size);

if (UNLIKELY(!doc || !doc->getValue())) {

dst_arr.clear();

return Status::InvalidArgument("jsonb data is invalid");

}

JsonbValue* obj_val;

if constexpr (JSONB_PATH_PARAM) {

if constexpr (!JSON_PATH_CONST) {

const ColumnString::Chars& rdata = jsonb_path_column->get_chars();

const ColumnString::Offsets& roffsets = jsonb_path_column->get_offsets();

size_t r_off = roffsets[i - 1];

size_t r_size = roffsets[i] - r_off;

const char* r_raw = reinterpret_cast<const char*>(&rdata[r_off]);

JsonbPath path;

if (!path.seek(r_raw, r_size)) {

return Status::InvalidArgument(

"Json path error: {} for value: {}",

JsonbErrMsg::getErrMsg(JsonbErrType::E_INVALID_JSON_PATH),

std::string_view(reinterpret_cast<const char*>(rdata.data()),

rdata.size()));

}

obj_val = doc->getValue()->findValue(path, nullptr);

} else {

obj_val = doc->getValue()->findValue(const_path, nullptr);

}

} else {

obj_val = doc->getValue();

}

if (!obj_val || !obj_val->isObject()) {

// if jsonb data is not object we should return null

res_null_map[i] = 1;

dst_arr.insert_default();

continue;

}

ObjectVal* obj = (ObjectVal*)obj_val;

for (auto it = obj->begin(); it != obj->end(); ++it) {

dst_nested_column.insert_data(it->getKeyStr(), it->klen());

}

dst_arr.get_offsets().push_back(dst_nested_column.size());

} //for

return Status::OK();

}

static constexpr auto name = "json_exists_path";

static constexpr auto alias = "jsonb_exists_path";

using ColumnType = ColumnVector<uint8_t>;

using Container = typename ColumnType::Container;

static FunctionPtr create() { return std::make_shared<FunctionJsonbExtractPath>(); }

String get_name() const override { return name; }

size_t get_number_of_arguments() const override { return 2; }

DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {

// it only needs to indicate existence and does not need to return nullable values.

return std::make_shared<DataTypeUInt8>();

}

Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,

uint32_t result, size_t input_rows_count) const override {

ColumnPtr jsonb_data_column;

bool jsonb_data_const = false;

// prepare jsonb data column

std::tie(jsonb_data_column, jsonb_data_const) =

unpack_if_const(block.get_by_position(arguments[0]).column);

const auto& ldata = assert_cast<const ColumnString*>(jsonb_data_column.get())->get_chars();

const auto& loffsets =

assert_cast<const ColumnString*>(jsonb_data_column.get())->get_offsets();

// prepare parse path column prepare

ColumnPtr path_column;

bool path_const = false;

std::tie(path_column, path_const) =

unpack_if_const(block.get_by_position(arguments[1]).column);

const auto* jsonb_path_column = assert_cast<const ColumnString*>(path_column.get());

auto res = ColumnType::create();

bool is_invalid_json_path = false;

const auto& rdata = jsonb_path_column->get_chars();

const auto& roffsets = jsonb_path_column->get_offsets();

if (jsonb_data_const) {

scalar_vector(context, jsonb_data_column->get_data_at(0), rdata, roffsets,

res->get_data(), is_invalid_json_path);

} else if (path_const) {

vector_scalar(context, ldata, loffsets, jsonb_path_column->get_data_at(0),

res->get_data(), is_invalid_json_path);

} else {

vector_vector(context, ldata, loffsets, rdata, roffsets, res->get_data(),

is_invalid_json_path);

}

if (is_invalid_json_path) {

return Status::InvalidArgument(

"Json path error: {} for value: {}",

JsonbErrMsg::getErrMsg(JsonbErrType::E_INVALID_JSON_PATH),

std::string_view(reinterpret_cast<const char*>(rdata.data()), rdata.size()));

}

block.get_by_position(result).column = std::move(res);

return Status::OK();

}

static ALWAYS_INLINE void inner_loop_impl(size_t i, Container& res, const char* l_raw_str,

size_t l_str_size, JsonbPath& path) {

// doc is NOT necessary to be deleted since JsonbDocument will not allocate memory

JsonbDocument* doc = JsonbDocument::checkAndCreateDocument(l_raw_str, l_str_size);

if (UNLIKELY(!doc || !doc->getValue())) {

return;

}

// value is NOT necessary to be deleted since JsonbValue will not allocate memory

JsonbValue* value = doc->getValue()->findValue(path, nullptr);

if (value) {

res[i] = 1;

}

}

static void vector_vector(FunctionContext* context, const ColumnString::Chars& ldata,

const ColumnString::Offsets& loffsets,

const ColumnString::Chars& rdata,

const ColumnString::Offsets& roffsets, Container& res,

bool& is_invalid_json_path) {

const size_t size = loffsets.size();

res.resize_fill(size, 0);

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

const char* l_raw_str = reinterpret_cast<const char*>(&ldata[loffsets[i - 1]]);

int l_str_size = loffsets[i] - loffsets[i - 1];

const char* r_raw_str = reinterpret_cast<const char*>(&rdata[roffsets[i - 1]]);

int r_str_size = roffsets[i] - roffsets[i - 1];

JsonbPath path;

if (!path.seek(r_raw_str, r_str_size)) {

is_invalid_json_path = true;

return;

}

inner_loop_impl(i, res, l_raw_str, l_str_size, path);

}

}

static void scalar_vector(FunctionContext* context, const StringRef& ldata,

const ColumnString::Chars& rdata,

const ColumnString::Offsets& roffsets, Container& res,

bool& is_invalid_json_path) {

const size_t size = roffsets.size();

res.resize_fill(size, 0);

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

const char* r_raw_str = reinterpret_cast<const char*>(&rdata[roffsets[i - 1]]);

int r_str_size = roffsets[i] - roffsets[i - 1];

JsonbPath path;

if (!path.seek(r_raw_str, r_str_size)) {

is_invalid_json_path = true;

return;

}

inner_loop_impl(i, res, ldata.data, ldata.size, path);

}

}

static void vector_scalar(FunctionContext* context, const ColumnString::Chars& ldata,

const ColumnString::Offsets& loffsets, const StringRef& rdata,

Container& res, bool& is_invalid_json_path) {

const size_t size = loffsets.size();

res.resize_fill(size, 0);

JsonbPath path;

if (!path.seek(rdata.data, rdata.size)) {

is_invalid_json_path = true;

return;

}

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

const char* l_raw_str = reinterpret_cast<const char*>(&ldata[loffsets[i - 1]]);

int l_str_size = loffsets[i] - loffsets[i - 1];

inner_loop_impl(i, res, l_raw_str, l_str_size, path);

}

}

using ReturnType = typename ValueType::ReturnType;

using ColumnType = typename ValueType::ColumnType;

static const bool only_check_exists = ValueType::only_check_exists;

static ALWAYS_INLINE void inner_loop_impl(size_t i, ColumnString::Chars& res_data,

ColumnString::Offsets& res_offsets, NullMap& null_map,

const std::unique_ptr<JsonbWriter>& writer,

std::unique_ptr<JsonbToJson>& formater,

const char* l_raw, size_t l_size, JsonbPath& path) {

if (null_map[i]) {

StringOP::push_null_string(i, res_data, res_offsets, null_map);

return;

}

// doc is NOT necessary to be deleted since JsonbDocument will not allocate memory

JsonbDocument* doc = JsonbDocument::checkAndCreateDocument(l_raw, l_size);

if (UNLIKELY(!doc || !doc->getValue())) {

StringOP::push_null_string(i, res_data, res_offsets, null_map);

return;

}

// value is NOT necessary to be deleted since JsonbValue will not allocate memory

JsonbValue* value = doc->getValue()->findValue(path, nullptr);

if (UNLIKELY(!value)) {

StringOP::push_null_string(i, res_data, res_offsets, null_map);

return;

}

if constexpr (ValueType::only_get_type) {

StringOP::push_value_string(std::string_view(value->typeName()), i, res_data,

res_offsets);

return;

}

if constexpr (std::is_same_v<DataTypeJsonb, ReturnType>) {

writer->reset();

writer->writeValue(value);

StringOP::push_value_string(std::string_view(writer->getOutput()->getBuffer(),

writer->getOutput()->getSize()),

i, res_data, res_offsets);

} else {

if (LIKELY(value->isString())) {

auto str_value = (JsonbStringVal*)value;

StringOP::push_value_string(

std::string_view(str_value->getBlob(), str_value->length()), i, res_data,

res_offsets);

} else if (value->isNull()) {

StringOP::push_value_string("null", i, res_data, res_offsets);

} else if (value->isTrue()) {

StringOP::push_value_string("true", i, res_data, res_offsets);

} else if (value->isFalse()) {

StringOP::push_value_string("false", i, res_data, res_offsets);

} else if (value->isInt8()) {

StringOP::push_value_string(std::to_string(((const JsonbInt8Val*)value)->val()), i,

res_data, res_offsets);

} else if (value->isInt16()) {

StringOP::push_value_string(std::to_string(((const JsonbInt16Val*)value)->val()), i,

res_data, res_offsets);

} else if (value->isInt32()) {

StringOP::push_value_string(std::to_string(((const JsonbInt32Val*)value)->val()), i,

res_data, res_offsets);

} else if (value->isInt64()) {

StringOP::push_value_string(std::to_string(((const JsonbInt64Val*)value)->val()), i,

res_data, res_offsets);

} else {

if (!formater) {

formater.reset(new JsonbToJson());

}

StringOP::push_value_string(formater->to_json_string(value), i, res_data,

res_offsets);

}

}

}

// for jsonb_extract_string

static Status vector_vector_v2(

FunctionContext* context, const ColumnString::Chars& ldata,

const ColumnString::Offsets& loffsets, const bool& json_data_const,

const std::vector<const ColumnString*>& rdata_columns, // here we can support more paths

const std::vector<bool>& path_const, ColumnString::Chars& res_data,

ColumnString::Offsets& res_offsets, NullMap& null_map, bool& is_invalid_json_path) {

size_t input_rows_count = json_data_const ? rdata_columns.size() : loffsets.size();

res_offsets.resize(input_rows_count);

auto writer = std::make_unique<JsonbWriter>();

std::unique_ptr<JsonbToJson> formater;

// reuseable json path list, espacially for const path

std::vector<JsonbPath> json_path_list;

json_path_list.resize(rdata_columns.size());

// lambda function to parse json path for row i and path pi

auto parse_json_path = [&](size_t i, size_t pi) -> Status {

const ColumnString* path_col = rdata_columns[pi];

const ColumnString::Chars& rdata = path_col->get_chars();

const ColumnString::Offsets& roffsets = path_col->get_offsets();

size_t r_off = roffsets[index_check_const(i, path_const[pi]) - 1];

size_t r_size = roffsets[index_check_const(i, path_const[pi])] - r_off;

const char* r_raw = reinterpret_cast<const char*>(&rdata[r_off]);

JsonbPath path;

if (!path.seek(r_raw, r_size)) {

return Status::InvalidArgument(

"Json path error: {} for value: {}",

JsonbErrMsg::getErrMsg(JsonbErrType::E_INVALID_JSON_PATH),

std::string_view(reinterpret_cast<const char*>(rdata.data()),

rdata.size()));

}

json_path_list[pi] = std::move(path);

return Status::OK();

};

for (size_t pi = 0; pi < rdata_columns.size(); pi++) {

if (path_const[pi]) {

RETURN_IF_ERROR(parse_json_path(0, pi));

}

}

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

if (null_map[i]) {

StringOP::push_null_string(i, res_data, res_offsets, null_map);

continue;

}

size_t l_off = loffsets[index_check_const(i, json_data_const) - 1];

size_t l_size = loffsets[index_check_const(i, json_data_const)] - l_off;

const char* l_raw = reinterpret_cast<const char*>(&ldata[l_off]);

if (rdata_columns.size() == 1) { // just return origin value

if (!path_const[0]) {

RETURN_IF_ERROR(parse_json_path(i, 0));

}

inner_loop_impl(i, res_data, res_offsets, null_map, writer, formater, l_raw, l_size,

json_path_list[0]);

} else { // will make array string to user

writer->reset();

writer->writeStartArray();

// doc is NOT necessary to be deleted since JsonbDocument will not allocate memory

JsonbDocument* doc = JsonbDocument::checkAndCreateDocument(l_raw, l_size);

for (size_t pi = 0; pi < rdata_columns.size(); ++pi) {

if (UNLIKELY(!doc || !doc->getValue())) {

writer->writeNull();

continue;

}

if (!path_const[pi]) {

RETURN_IF_ERROR(parse_json_path(i, pi));

}

// value is NOT necessary to be deleted since JsonbValue will not allocate memory

JsonbValue* value = doc->getValue()->findValue(json_path_list[pi], nullptr);

if (UNLIKELY(!value)) {

writer->writeNull();

} else {

writer->writeValue(value);

}

}

writer->writeEndArray();

StringOP::push_value_string(std::string_view(writer->getOutput()->getBuffer(),

writer->getOutput()->getSize()),

i, res_data, res_offsets);

}

} //for

return Status::OK();

}

static void vector_vector(FunctionContext* context, const ColumnString::Chars& ldata,

const ColumnString::Offsets& loffsets,

const ColumnString::Chars& rdata,

const ColumnString::Offsets& roffsets, ColumnString::Chars& res_data,

ColumnString::Offsets& res_offsets, NullMap& null_map,

bool& is_invalid_json_path) {

size_t input_rows_count = loffsets.size();

res_offsets.resize(input_rows_count);

std::unique_ptr<JsonbWriter> writer;

if constexpr (std::is_same_v<DataTypeJsonb, ReturnType>) {

writer.reset(new JsonbWriter());

}

std::unique_ptr<JsonbToJson> formater;

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

int l_size = loffsets[i] - loffsets[i - 1];

const char* l_raw = reinterpret_cast<const char*>(&ldata[loffsets[i - 1]]);

int r_size = roffsets[i] - roffsets[i - 1];

const char* r_raw = reinterpret_cast<const char*>(&rdata[roffsets[i - 1]]);

JsonbPath path;

if (!path.seek(r_raw, r_size)) {

is_invalid_json_path = true;

StringOP::push_null_string(i, res_data, res_offsets, null_map);

return;

}

inner_loop_impl(i, res_data, res_offsets, null_map, writer, formater, l_raw, l_size,

path);

} //for

} //function

static void vector_scalar(FunctionContext* context, const ColumnString::Chars& ldata,

const ColumnString::Offsets& loffsets, const StringRef& rdata,

ColumnString::Chars& res_data, ColumnString::Offsets& res_offsets,

NullMap& null_map, bool& is_invalid_json_path) {

size_t input_rows_count = loffsets.size();

res_offsets.resize(input_rows_count);

std::unique_ptr<JsonbWriter> writer;

if constexpr (std::is_same_v<DataTypeJsonb, ReturnType>) {

writer.reset(new JsonbWriter());

}

std::unique_ptr<JsonbToJson> formater;

JsonbPath path;

if (!path.seek(rdata.data, rdata.size)) {

is_invalid_json_path = true;

return;

}

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

int l_size = loffsets[i] - loffsets[i - 1];

const char* l_raw = reinterpret_cast<const char*>(&ldata[loffsets[i - 1]]);

inner_loop_impl(i, res_data, res_offsets, null_map, writer, formater, l_raw, l_size,

path);

} //for

} //function

static void scalar_vector(FunctionContext* context, const StringRef& ldata,

const ColumnString::Chars& rdata,

const ColumnString::Offsets& roffsets, ColumnString::Chars& res_data,

ColumnString::Offsets& res_offsets, NullMap& null_map,

bool& is_invalid_json_path) {

size_t input_rows_count = roffsets.size();

res_offsets.resize(input_rows_count);

std::unique_ptr<JsonbWriter> writer;

if constexpr (std::is_same_v<DataTypeJsonb, ReturnType>) {

writer.reset(new JsonbWriter());

}

std::unique_ptr<JsonbToJson> formater;

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