hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity
Files
d30759b78c046eabb2e1b23c980ccc8d53d5c5fa
oceanbase/src/storage/ob_storage_util.cpp
haitaoyang 0546a585e2 adjust some log and comment
2024-10-16 21:44:23 +00:00

789 lines
31 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#include "ob_storage_util.h"
#include "lib/worker.h"
#include "share/datum/ob_datum.h"
#include "share/object/ob_obj_cast.h"
#include "share/vector/ob_discrete_format.h"
#include "sql/engine/basic/ob_pushdown_filter.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/engine/expr/ob_array_expr_utils.h"
#include "storage/blocksstable/ob_datum_row.h"
namespace oceanbase
{
using namespace common;
namespace storage
{
static const ObString OB_DEFAULT_PADDING_STRING(1, 1, &OB_PADDING_CHAR);
OB_INLINE static const ObString get_padding_str(ObCollationType coll_type)
{
if (!ObCharset::is_cs_nonascii(coll_type)) {
return OB_DEFAULT_PADDING_STRING;
} else {
return ObCharsetUtils::get_const_str(coll_type, OB_PADDING_CHAR);
}
}
OB_INLINE static void append_padding_pattern(const ObString &space_pattern,
const int32_t offset,
const int32_t buf_len,
char *&buf,
int32_t &true_len)
{
true_len = offset;
if (OB_UNLIKELY((buf_len - offset) < space_pattern.length())) {
} else if (1 == space_pattern.length()) {
MEMSET(buf + offset, space_pattern[0], buf_len - offset);
true_len = buf_len;
} else {
for (int32_t i = offset; i <= (buf_len - space_pattern.length()); i += space_pattern.length()) {
MEMCPY(buf + i, space_pattern.ptr(), space_pattern.length());
true_len += space_pattern.length();
}
}
}
OB_INLINE static int pad_on_local_buf(const ObString &space_pattern,
int32_t pad_whitespace_length,
common::ObIAllocator &padding_alloc,
const char *&ptr,
uint32_t &length)
{
int ret = OB_SUCCESS;
char *buf = nullptr;
const int32_t pad_len = length + pad_whitespace_length * space_pattern.length();
const int64_t buf_len = lib::is_oracle_mode() ? MIN(pad_len, OB_MAX_ORACLE_CHAR_LENGTH_BYTE) : pad_len;
if (OB_ISNULL((buf = (char*) padding_alloc.alloc(buf_len)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "no memory", K(ret));
} else {
int32_t true_len = 0;
MEMCPY(buf, ptr, length);
append_padding_pattern(space_pattern, length, buf_len, buf, true_len);
ptr = buf;
length = true_len;
}
return ret;
}
int pad_column(const ObAccuracy accuracy, common::ObIAllocator &padding_alloc, common::ObObj &cell)
{
int ret = OB_SUCCESS;
if (cell.is_fixed_len_char_type()) {
ObLength length = accuracy.get_length(); // byte or char length
int32_t cell_strlen = 0; // byte or char length
const ObString space_pattern = get_padding_str(cell.get_collation_type());
if (OB_FAIL(cell.get_char_length(accuracy, *(reinterpret_cast<int32_t *>(&cell_strlen)), lib::is_oracle_mode()))) {
STORAGE_LOG(WARN, "Fail to get char length, ", K(ret));
} else {
if (cell_strlen < length) {
uint32_t cell_len = cell.get_val_len();
const char *ptr = cell.get_string_ptr();
if (OB_FAIL(pad_on_local_buf(space_pattern, (length - cell_strlen), padding_alloc,
ptr, cell_len))) {
STORAGE_LOG(WARN, "Fail to pad on local buf, ", K(ret), K(cell), K(length), K(cell_strlen));
} else {
// watch out !!! in order to deep copy an ObObj instance whose type is char or varchar,
// set_collation_type() should be revoked. But here no need to set collation type
cell.set_string(cell.get_type(), ObString(cell_len, cell_len, ptr));
}
}
}
}
return ret;
}
int pad_column(const ObObjMeta &obj_meta, const ObAccuracy accuracy, common::ObIAllocator &padding_alloc, blocksstable::ObStorageDatum &datum)
{
int ret = OB_SUCCESS;
if (datum.is_null()) {
// do nothing.
} else if (obj_meta.is_fixed_len_char_type()) {
ObLength length = accuracy.get_length(); // byte or char length
const common::ObCollationType cs_type = obj_meta.get_collation_type();
const ObString space_pattern = get_padding_str(cs_type);
int32_t cur_len = 0; // byte or char length
bool is_ascii = can_do_ascii_optimize(cs_type) && is_ascii_str(datum.ptr_, datum.pack_);
if (is_ascii || is_oracle_byte_length(lib::is_oracle_mode(), accuracy.get_length_semantics())) {
cur_len = datum.pack_;
} else {
cur_len = static_cast<int32_t>(ObCharset::strlen_char(cs_type, datum.ptr_, datum.pack_));
}
if (cur_len < length &&
OB_FAIL(pad_on_local_buf(space_pattern, length - cur_len, padding_alloc, datum.ptr_, datum.pack_))) {
STORAGE_LOG(WARN, "fail to pad on padding allocator", K(ret), K(length), K(cur_len), K(datum));
}
}
return ret;
}
int pad_column(const common::ObAccuracy accuracy, sql::ObEvalCtx &ctx, sql::ObExpr &expr)
{
int ret = OB_SUCCESS;
sql::ObDatum &datum = expr.locate_expr_datum(ctx);
if (datum.is_null()) {
// do nothing.
} else if (expr.obj_meta_.is_fixed_len_char_type()) {
ObLength length = accuracy.get_length(); // byte or char length
const common::ObCollationType cs_type = expr.datum_meta_.cs_type_;
const ObString space_pattern = get_padding_str(cs_type);
int32_t cur_len = 0; // byte or char length
bool is_ascii = can_do_ascii_optimize(cs_type) && is_ascii_str(datum.ptr_, datum.pack_);
if (is_ascii || is_oracle_byte_length(lib::is_oracle_mode(), accuracy.get_length_semantics())) {
cur_len = datum.pack_;
} else {
cur_len = static_cast<int32_t>(ObCharset::strlen_char(cs_type, datum.ptr_, datum.pack_));
}
if (cur_len < length) {
char *ptr = nullptr;
const int32_t pad_len = datum.pack_ + (length - cur_len) * space_pattern.length();
const int64_t buf_len = lib::is_oracle_mode() ? MIN(pad_len, OB_MAX_ORACLE_CHAR_LENGTH_BYTE) : pad_len;
if (OB_ISNULL(ptr = expr.get_str_res_mem(ctx, buf_len))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "no memory", K(ret));
} else {
int32_t true_len = 0;
MEMMOVE(ptr, datum.ptr_, datum.pack_);
append_padding_pattern(space_pattern, datum.pack_, buf_len, ptr, true_len);
datum.ptr_ = ptr;
datum.pack_ = true_len;
}
}
}
return ret;
}
int pad_on_datums(const common::ObAccuracy accuracy,
const common::ObCollationType cs_type,
common::ObIAllocator &padding_alloc,
int64_t row_count,
common::ObDatum *&datums)
{
int ret = OB_SUCCESS;
ObLength length = accuracy.get_length(); // byte or char length
const ObString space_pattern = get_padding_str(cs_type);
bool is_oracle_byte = is_oracle_byte_length(lib::is_oracle_mode(), accuracy.get_length_semantics());
char *buf = nullptr;
if (1 == length) {
int32_t buf_len = space_pattern.length();
if (OB_ISNULL((buf = (char*) padding_alloc.alloc(buf_len)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "no memory", K(ret));
} else {
int32_t true_len = 0;
append_padding_pattern(space_pattern, 0, buf_len, buf, true_len);
for (int64_t i = 0; i < row_count; i++) {
common::ObDatum &datum = datums[i];
if (datum.is_null()) {
// do nothing
} else if (0 == datum.pack_){
datum.ptr_ = buf;
datum.pack_ = true_len;
}
}
}
} else if (can_do_ascii_optimize(cs_type)) {
int32_t buf_len = length * space_pattern.length() * row_count;
if (OB_ISNULL(buf = (char*) padding_alloc.alloc(buf_len))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "no memory", K(ret));
} else {
char *ptr = buf;
MEMSET(buf, OB_PADDING_CHAR, buf_len);
for (int64_t i = 0; OB_SUCC(ret) && i < row_count; i++) {
common::ObDatum &datum = datums[i];
if (datum.is_null()) {
// do nothing
} else {
if (is_oracle_byte || is_ascii_str(datum.ptr_, datum.pack_)) {
if (datum.pack_ < length) {
MEMCPY(ptr, datum.ptr_, datum.pack_);
datum.ptr_ = ptr;
datum.pack_ = length;
ptr = ptr + length;
}
} else {
int32_t cur_len = static_cast<int32_t>(ObCharset::strlen_char(cs_type, datum.ptr_, datum.pack_));
if (cur_len < length &&
OB_FAIL(pad_on_local_buf(space_pattern, length - cur_len, padding_alloc, datum.ptr_, datum.pack_))) {
STORAGE_LOG(WARN, "fail to pad on padding allocator", K(ret), K(length), K(cur_len), K(datum));
}
}
}
}
}
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < row_count; i++) {
common::ObDatum &datum = datums[i];
if (datum.is_null()) {
// do nothing
} else {
int32_t cur_len = 0; // byte or char length
if (is_oracle_byte) {
cur_len = datum.pack_;
} else {
cur_len = static_cast<int32_t>(ObCharset::strlen_char(cs_type, datum.ptr_, datum.pack_));
}
if (cur_len < length &&
OB_FAIL(pad_on_local_buf(space_pattern, length - cur_len, padding_alloc, datum.ptr_, datum.pack_))) {
STORAGE_LOG(WARN, "fail to pad on padding allocator", K(ret), K(length), K(cur_len), K(datum));
}
}
}
}
return ret;
}
int pad_on_rich_format_columns(const common::ObAccuracy accuracy,
const common::ObCollationType cs_type,
const int64_t row_count,
const int64_t vec_offset,
common::ObIAllocator &padding_alloc,
sql::ObExpr &expr,
sql::ObEvalCtx &eval_ctx)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(VectorFormat::VEC_DISCRETE != expr.get_format(eval_ctx))) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected vector format for padding column", K(expr.get_format(eval_ctx)));
} else {
ObDiscreteFormat *discrete_format = static_cast<ObDiscreteFormat *>(expr.get_vector(eval_ctx));
ObLength *lens = discrete_format->get_lens();
char **ptrs = discrete_format->get_ptrs();
sql::ObBitVector *nulls = discrete_format->get_nulls();
ObLength length = accuracy.get_length(); // byte or char length
const ObString space_pattern = get_padding_str(cs_type);
bool is_oracle_byte = is_oracle_byte_length(lib::is_oracle_mode(), accuracy.get_length_semantics());
char *buf = nullptr;
if (1 == length) {
int32_t buf_len = space_pattern.length();
if (OB_ISNULL((buf = (char*) padding_alloc.alloc(buf_len)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "no memory", K(ret));
} else {
int32_t true_len = 0;
append_padding_pattern(space_pattern, 0, buf_len, buf, true_len);
for (int64_t i = vec_offset; i < vec_offset + row_count; i++) {
if (nulls->at(i)) {
// do nothing
} else if (0 == lens[i]){
ptrs[i] = buf;
lens[i] = true_len;
}
}
}
} else if (can_do_ascii_optimize(cs_type)) {
int32_t buf_len = length * space_pattern.length() * row_count;
if (OB_ISNULL(buf = (char*) padding_alloc.alloc(buf_len))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "no memory", K(ret));
} else {
char *ptr = buf;
MEMSET(buf, OB_PADDING_CHAR, buf_len);
for (int64_t i = vec_offset; OB_SUCC(ret) && i < vec_offset + row_count; i++) {
if (nulls->at(i)) {
// do nothing
} else {
if (is_oracle_byte || is_ascii_str(ptrs[i], lens[i])) {
if (lens[i] < length) {
MEMCPY(ptr, ptrs[i], lens[i]);
ptrs[i] = ptr;
lens[i] = length;
ptr = ptr + length;
}
} else {
int32_t cur_len = static_cast<int32_t>(ObCharset::strlen_char(cs_type, ptrs[i], lens[i]));
if (cur_len < length &&
OB_FAIL(pad_on_local_buf(space_pattern, length - cur_len, padding_alloc, (const char *&)ptrs[i], (uint32_t &)lens[i]))) {
STORAGE_LOG(WARN, "fail to pad on padding allocator", K(ret), K(length), K(cur_len));
}
}
}
}
}
} else {
for (int64_t i = vec_offset; OB_SUCC(ret) && i < vec_offset + row_count; i++) {
if (nulls->at(i)) {
// do nothing
} else {
int32_t cur_len = 0; // byte or char length
if (is_oracle_byte) {
cur_len = lens[i];
} else {
cur_len = static_cast<int32_t>(ObCharset::strlen_char(cs_type, ptrs[i], lens[i]));
}
if (cur_len < length &&
OB_FAIL(pad_on_local_buf(space_pattern, length - cur_len, padding_alloc, (const char *&)ptrs[i], (uint32_t &)lens[i]))) {
STORAGE_LOG(WARN, "fail to pad on padding allocator", K(ret), K(length), K(cur_len));
}
}
}
}
}
return ret;
}
int distribute_attrs_on_rich_format_columns(const int64_t row_count, const int64_t vec_offset,
sql::ObExpr &expr, sql::ObEvalCtx &eval_ctx)
{
return ObArrayExprUtils::batch_dispatch_array_attrs(eval_ctx, expr, vec_offset, row_count);
}
int cast_obj(const common::ObObjMeta &src_meta,
common::ObIAllocator &cast_allocator,
common::ObObj &obj)
{
int ret = OB_SUCCESS;
const ObObjTypeClass type_class = src_meta.get_type_class();
bool need_cast = true;
bool empty_str = false;
switch (type_class) {
case ObIntTC: {
need_cast = src_meta.get_type() < obj.get_type();
break;
}
case ObUIntTC: {
need_cast = (obj.get_int() < 0
|| static_cast<uint64_t>(obj.get_int()) > UINT_MAX_VAL[src_meta.get_type()]);
break;
}
case ObFloatTC: {
need_cast = (obj.get_float() < 0.0);
break;
}
case ObDoubleTC: {
need_cast = (obj.get_double() < 0.0);
break;
}
case ObNumberTC: {
need_cast = obj.is_negative_number();
break;
}
case ObStringTC: {
need_cast = (obj.get_collation_type() != src_meta.get_collation_type());
empty_str = 0 == obj.get_val_len();
break;
}
case ObTextTC: {
need_cast = obj.is_inrow() && (obj.get_collation_type() != src_meta.get_collation_type());
empty_str = 0 == obj.get_val_len();
break;
}
default: {
need_cast = false;
}
}
if (ObNullType == obj.get_type() || ObExtendType == obj.get_type()) {
//ignore src_meta type, do nothing, just return obj
} else if ((obj.get_type() == src_meta.get_type() && !need_cast) || empty_str) {//just change the type
obj.set_type(src_meta.get_type());
if (empty_str && ObTextTC == type_class) {
obj.set_inrow();
}
} else {
//not support data alteration
ObObj ori_obj = obj;
int64_t cm_mode = CM_NONE;
//int to uint not check range bug:
if(ObIntTC == ori_obj.get_type_class() && ObUIntTC == type_class) {
obj.set_uint(src_meta.get_type(), static_cast<uint64_t>(ori_obj.get_int()));
} else if (ObIntTC == ori_obj.get_type_class() && ObBitTC == type_class) {
obj.set_bit(static_cast<uint64_t>(ori_obj.get_int()));
} else {
ObCastCtx cast_ctx(&cast_allocator, NULL, cm_mode, src_meta.get_collation_type());
if(OB_FAIL(ObObjCaster::to_type(src_meta.get_type(), cast_ctx, ori_obj, obj))) {
STORAGE_LOG(WARN, "fail to cast obj",
K(ret), K(ori_obj), K(obj), K(ori_obj.get_type()),
K(ob_obj_type_str(ori_obj.get_type())),
K(src_meta.get_type()), K(ob_obj_type_str(src_meta.get_type())));
}
}
}
return ret;
}
int fill_datums_lob_locator(
const ObTableIterParam &iter_param,
const ObTableAccessContext &context,
const share::schema::ObColumnParam &col_param,
const int64_t row_cap,
ObDatum *datums,
bool reuse_lob_locator)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!col_param.get_meta_type().is_lob_storage() ||
nullptr == context.lob_locator_helper_)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected param", K(ret), K(col_param.get_meta_type()), K(context.lob_locator_helper_));
} else {
if (reuse_lob_locator) {
context.lob_locator_helper_->reuse();
}
for (int64_t row_idx = 0; OB_SUCC(ret) && row_idx < row_cap; ++row_idx) {
ObDatum &datum = datums[row_idx];
if (!datum.is_null() && !datum.get_lob_data().in_row_) {
if (OB_FAIL(context.lob_locator_helper_->fill_lob_locator_v2(datum, col_param, iter_param, context))) {
STORAGE_LOG(WARN, "Failed to fill lob loactor", K(ret), K(row_idx), K(datum), K(context), K(iter_param));
}
}
}
}
return ret;
}
int fill_exprs_lob_locator(
const ObTableIterParam &iter_param,
const ObTableAccessContext &context,
const share::schema::ObColumnParam &col_param,
sql::ObExpr &expr,
sql::ObEvalCtx &eval_ctx,
const int64_t vector_offset,
const int64_t row_cap)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!col_param.get_meta_type().is_lob_storage() ||
nullptr == context.lob_locator_helper_ ||
VectorFormat::VEC_DISCRETE != expr.get_format(eval_ctx))) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected param", K(ret), K(col_param.get_meta_type()),
K(context.lob_locator_helper_), K(expr.get_format(eval_ctx)));
} else {
ObDiscreteFormat *discrete_format = static_cast<ObDiscreteFormat *>(expr.get_vector(eval_ctx));
ObDatum datum;
ObLength length;
for (int64_t row_idx = vector_offset; OB_SUCC(ret) && (row_idx < row_cap + vector_offset); ++row_idx) {
if (!discrete_format->is_null(row_idx)) {
discrete_format->get_payload(row_idx, datum.ptr_, length);
datum.len_ = static_cast<uint32_t>(length);
if (!datum.get_lob_data().in_row_) {
if (OB_FAIL(context.lob_locator_helper_->fill_lob_locator_v2(datum, col_param, iter_param, context))) {
STORAGE_LOG(WARN, "Failed to fill lob loactor", K(ret), K(row_idx), K(datum), K(context), K(iter_param));
} else {
discrete_format->set_datum(row_idx, datum);
}
}
}
}
}
return ret;
}
// Monotonic black filter only support ">", ">=", "<", "<=", "=" five types.
// All of these monotonic black filters will return false if the input is null.
// When has_null is true, we can not set_always_true() for bool_mask but can judge always false.
int check_skip_by_monotonicity(
sql::ObBlackFilterExecutor &filter,
blocksstable::ObStorageDatum &min_datum,
blocksstable::ObStorageDatum &max_datum,
const sql::ObBitVector &skip_bit,
const bool has_null,
ObBitmap *result_bitmap,
sql::ObBoolMask &bool_mask)
{
int ret = OB_SUCCESS;
bool_mask.set_uncertain();
if (min_datum.is_null() || max_datum.is_null()) {
// uncertain
} else {
const sql::PushdownFilterMonotonicity mono = filter.get_monotonicity();
bool is_asc = false;
switch (mono) {
case sql::PushdownFilterMonotonicity::MON_ASC: {
is_asc = true;
}
case sql::PushdownFilterMonotonicity::MON_DESC: {
bool filtered = false;
ObStorageDatum &false_datum = is_asc ? max_datum : min_datum;
ObStorageDatum &true_datum = is_asc ? min_datum : max_datum;
if (OB_FAIL(filter.filter(false_datum, skip_bit, filtered))) {
STORAGE_LOG(WARN, "Failed to compare with false_datum", K(ret), K(false_datum), K(is_asc));
} else if (filtered) {
bool_mask.set_always_false();
} else if (!has_null) {
if (OB_FAIL(filter.filter(true_datum, skip_bit, filtered))) {
STORAGE_LOG(WARN, "Failed to compare with true_datum", K(ret), K(true_datum), K(is_asc));
} else if (!filtered) {
bool_mask.set_always_true();
}
}
break;
}
case sql::PushdownFilterMonotonicity::MON_EQ_ASC: {
is_asc = true;
}
case sql::PushdownFilterMonotonicity::MON_EQ_DESC: {
bool min_cmp_res = false;
bool max_cmp_res = false;
if (OB_FAIL(filter.judge_greater_or_less(min_datum, skip_bit, is_asc, min_cmp_res))) {
STORAGE_LOG(WARN, "Failed to judge min_datum", K(ret), K(min_datum));
} else if (min_cmp_res) {
bool_mask.set_always_false();
} else if (OB_FAIL(filter.judge_greater_or_less(max_datum, skip_bit, !is_asc, max_cmp_res))) {
STORAGE_LOG(WARN, "Failed to judge max_datum", K(ret), K(max_datum));
} else if (max_cmp_res) {
bool_mask.set_always_false();
} else if (!has_null) {
if (OB_FAIL(filter.filter(min_datum, skip_bit, min_cmp_res))) {
STORAGE_LOG(WARN, "Failed to compare with min_datum", K(ret), K(min_datum));
} else if (min_cmp_res) {
// min datum is filtered
} else if (OB_FAIL(filter.filter(max_datum, skip_bit, max_cmp_res))) {
STORAGE_LOG(WARN, "Failed to compare with max_datum", K(ret), K(max_datum));
} else if (!max_cmp_res) {
// min datum and max datum are both not filtered
bool_mask.set_always_true();
}
}
break;
}
default: {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected monotonicity", K(ret), K(mono));
}
}
}
if (OB_SUCC(ret) && nullptr != result_bitmap){
if (bool_mask.is_always_false()) {
result_bitmap->reuse(false);
} else if (bool_mask.is_always_true()) {
result_bitmap->reuse(true);
}
}
return ret;
}
int reverse_trans_version_val(common::ObDatum *datums, const int64_t count)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(nullptr == datums || count < 0)) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid argument", K(ret), KP(datums), K(count));
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < count; ++i) {
common::ObDatum &datum = datums[i];
if (OB_UNLIKELY(datum.is_nop() || datum.is_null() || datum.get_int() > 0)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected datum value", K(ret), K(datum));
} else {
datum.set_int(-datum.get_int());
}
}
}
return ret;
}
int reverse_trans_version_val(ObIVector *vector, const int64_t count)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(nullptr == vector || count < 0)) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid argument", K(ret), KP(vector), K(count));
} else if (OB_UNLIKELY(vector->get_format() != VectorFormat::VEC_FIXED)) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected vector format for trans version col", K(ret), K(vector->get_format()));
} else {
ObFixedLengthBase *fixed_length_base = static_cast<ObFixedLengthBase *>(vector);
if (OB_UNLIKELY(fixed_length_base->has_null() || fixed_length_base->get_length() != sizeof(int64_t))) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "Unexpected vector", K(ret), K(fixed_length_base->has_null()), K(fixed_length_base->get_length()));
} else {
int64_t *ver_ptr = reinterpret_cast<int64_t *>(fixed_length_base->get_data());
for (int64_t i = 0; i < count; ++i) {
ver_ptr[i] = -ver_ptr[i];
}
}
}
return ret;
}
const char *ObMviewScanInfo::OLD_ROW = "O";
const char *ObMviewScanInfo::NEW_ROW = "N";
const char *ObMviewScanInfo::FINAL_ROW = "F";
int ObMviewScanInfo::init(
const bool is_mv_refresh_query,
const StorageScanType scan_type,
const int64_t begin_version,
const int64_t end_version,
const common::ObIArray<sql::ObExpr *> &non_mview_filters)
{
int ret = OB_SUCCESS;
if (non_mview_filters.count() > 0 && OB_FAIL(op_filters_.reserve(non_mview_filters.count()))) {
STORAGE_LOG(WARN, "Failed to reserve op filters", K(ret));
} else {
is_mv_refresh_query_ = is_mv_refresh_query;
scan_type_ = scan_type;
begin_version_ = begin_version;
end_version_ = end_version;
for (int64_t i = 0; OB_SUCC(ret) && i < non_mview_filters.count(); ++i) {
if (OB_FAIL(op_filters_.push_back(non_mview_filters.at(i)))) {
STORAGE_LOG(WARN, "Failed to push back", K(ret));
}
}
}
return ret;
}
int ObMviewScanInfo::check_and_update_version_range(const int64_t multi_version_start, common::ObVersionRange &origin_range)
{
int ret = OB_SUCCESS;
bool is_verion_valid = 0 == origin_range.base_version_ &&
(!is_end_valid() || end_version_ == origin_range.snapshot_version_) &&
(!is_begin_valid() || begin_version_ < origin_range.snapshot_version_);
if (OB_UNLIKELY(!is_verion_valid)) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid mview query version", K(ret), K(multi_version_start), K(origin_range), K(*this));
} else if (OB_UNLIKELY(is_begin_valid() && begin_version_ < multi_version_start)) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "begin version is oldder than tablet's multi version start", K(ret), K(multi_version_start), K(origin_range), K(*this));
} else {
if (is_begin_valid()) {
origin_range.base_version_ = begin_version_;
}
}
return ret;
}
int decimal_or_number_to_int64(const ObDatum &datum,
const ObDatumMeta &datum_meta,
int64_t &res)
{
int ret = OB_SUCCESS;
ObObjType ob_type = datum_meta.get_type();
if (ObNumberType == ob_type) {
const number::ObNumber nmb(datum.get_number());
if (OB_FAIL(nmb.extract_valid_int64_with_trunc(res))) {
STORAGE_LOG(WARN, "failed to cast number to int64", K(ret));
}
} else if (ObDecimalIntType == ob_type) {
int32_t int_bytes = wide::ObDecimalIntConstValue::get_int_bytes_by_precision(datum_meta.precision_);
bool is_valid;
if (OB_FAIL(wide::check_range_valid_int64(datum.get_decimal_int(), int_bytes, is_valid, res))) {
STORAGE_LOG(WARN, "failed to check decimal int", K(int_bytes), K(ret));
} else if (!is_valid) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "decimal int is not valid int64", K(ret));
}
} else {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "unexpected type", K(ob_type), K(ret));
}
return ret;
}
// extract mview info from filter: ora_rowscn > V0 and ora_rowscn <= V1 and $OLD_NEW='O|N|F'
int build_mview_scan_info_if_need(
const common::ObQueryFlag query_flag,
const sql::ObExprPtrIArray *op_filters,
sql::ObEvalCtx &eval_ctx,
common::ObIAllocator *alloc,
ObMviewScanInfo *&mview_scan_info)
{
int ret = OB_SUCCESS;
StorageScanType scan_type = StorageScanType::NORMAL;
int64_t begin_version = -1;
int64_t end_version = -1;
common::ObSEArray<sql::ObExpr *, 4> non_mview_filters;
if (OB_UNLIKELY(nullptr == alloc || nullptr != mview_scan_info ||
nullptr == op_filters || op_filters->count() < 1)) {
ret = OB_INVALID_ARGUMENT;
STORAGE_LOG(WARN, "Invalid argument", K(ret), KP(alloc), KP(mview_scan_info), KP(op_filters));
} else {
sql::ObExpr *e = nullptr;
ObDatum *datum = NULL;
ObEvalCtx::BatchInfoScopeGuard batch_info_guard(eval_ctx);
batch_info_guard.set_batch_size(1);
for (int64_t i = 0; OB_SUCC(ret) && i < op_filters->count(); ++i) {
if (OB_ISNULL(e = op_filters->at(i))) {
ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "expr is null", K(ret), K(i));
} else if (T_OP_EQ == e->type_ && 2 == e->arg_cnt_ &&
T_PSEUDO_OLD_NEW_COL == e->args_[0]->type_ && e->args_[1]->is_static_const_) {
if (OB_FAIL(e->args_[1]->eval(eval_ctx, datum))) {
STORAGE_LOG(WARN, "Failed to eval const expr", K(ret));
} else if (0 == ObString::make_string(ObMviewScanInfo::OLD_ROW).case_compare(datum->get_string())) {
scan_type = StorageScanType::MVIEW_FIRST_DELETE;
} else if (0 == ObString::make_string(ObMviewScanInfo::NEW_ROW).case_compare(datum->get_string())) {
scan_type = StorageScanType::MVIEW_LAST_INSERT;
} else if (0 == ObString::make_string(ObMviewScanInfo::FINAL_ROW).case_compare(datum->get_string())) {
scan_type = StorageScanType::MVIEW_FINAL_ROW;
} else {
ret = OB_NOT_SUPPORTED;
STORAGE_LOG(WARN, "Not supported OLD_NEW type", K(ret), KPC(datum));
}
} else if (OB_FAIL(non_mview_filters.push_back(e))) {
STORAGE_LOG(WARN, "Failed to push back non mview filter", K(ret), K(i));
} else if ((T_OP_GT == e->type_ || T_OP_LE == e->type_) && 2 == e->arg_cnt_) {
sql::ObExpr *left = e->args_[0];
sql::ObExpr *right = e->args_[1];
int64_t rowscn = -1;
if (T_ORA_ROWSCN != left->type_ && lib::is_oracle_mode()) {
if (T_FUN_SYS_CAST == left->type_ &&
2 == left->arg_cnt_ &&
T_ORA_ROWSCN == left->args_[0]->type_ ) {
left = left->args_[0];
} else {
left = nullptr;
}
}
if (nullptr != left &&
T_ORA_ROWSCN == left->type_ && (right->is_static_const_ || T_FUN_SYS_LAST_REFRESH_SCN == right->type_)) {
if (OB_FAIL(right->eval(eval_ctx, datum))) {
STORAGE_LOG(WARN, "Failed to eval const expr", K(ret));
} else if (lib::is_oracle_mode()) {
if (OB_FAIL(decimal_or_number_to_int64(*datum, right->datum_meta_, rowscn))) {
STORAGE_LOG(WARN, "Failed to get rowscn", K(ret));
}
} else {
rowscn = datum->get_int();
}
if (OB_FAIL(ret)) {
} else if (T_OP_GT == e->type_) {
begin_version = rowscn;
} else {
end_version = rowscn;
}
}
}
}
}
if (OB_FAIL(ret)) {
} else if (StorageScanType::NORMAL == scan_type) {
STORAGE_LOG(INFO, "no need use mview scan", K(scan_type), K(begin_version), K(end_version));
} else if (OB_ISNULL(mview_scan_info = OB_NEWx(ObMviewScanInfo, alloc, alloc))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
STORAGE_LOG(WARN, "Failed to alloc memory for mview scan info", K(ret));
} else if (OB_FAIL(mview_scan_info->init(query_flag.is_mr_mview_refresh_base_scan(), scan_type, begin_version, end_version, non_mview_filters))) {
STORAGE_LOG(WARN, "Failed to init mview scan info", K(ret));
}
STORAGE_LOG(TRACE, "[MVIEW QUERY]: build mview scan info", K(ret), KPC(mview_scan_info));
return ret;
}
void release_mview_scan_info(common::ObIAllocator *alloc, ObMviewScanInfo *&mview_scan_info)
{
if (nullptr != mview_scan_info) {
mview_scan_info->~ObMviewScanInfo();
if (nullptr != alloc) {
alloc->free(mview_scan_info);
}
mview_scan_info = nullptr;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink