[SCN] adjust ObBatchCreateTabletArg
This commit is contained in:
obdev
ob-robot
parent
4c49f6e7c5
commit
c538314fd7
1
deps/init/oceanbase.el7.aarch64.deps
vendored
1
deps/init/oceanbase.el7.aarch64.deps
vendored
@ -17,7 +17,6 @@ repo=http://yum.tbsite.net/taobao/7/aarch64/test/ob-deploy/
|
||||
devdeps-gtest-1.8.0-132022101316.el7.aarch64.rpm
|
||||
devdeps-isa-l-static-2.22.0-22022092915.el7.aarch64.rpm
|
||||
devdeps-libcurl-static-7.29.0-32022093010.el7.aarch64.rpm
|
||||
devdeps-libunwind-static-1.6.2-222022100410.el7.aarch64.rpm
|
||||
devdeps-mariadb-connector-c-3.1.12-12022100422.el7.aarch64.rpm
|
||||
devdeps-libaio-0.3.112-12022092915.el7.aarch64.rpm
|
||||
devdeps-rapidjson-1.1.0-12022100410.el7.aarch64.rpm
|
||||
|
||||
1
deps/init/oceanbase.el8.aarch64.deps
vendored
1
deps/init/oceanbase.el8.aarch64.deps
vendored
@ -12,7 +12,6 @@ repo=http://mirrors.aliyun.com/oceanbase/community/stable/el/8/aarch64/
|
||||
devdeps-gtest-1.8.0-132022101316.el8.aarch64.rpm
|
||||
devdeps-isa-l-static-2.22.0-22022092915.el8.aarch64.rpm
|
||||
devdeps-libcurl-static-7.29.0-32022093010.el8.aarch64.rpm
|
||||
devdeps-libunwind-static-1.6.2-222022100410.el8.aarch64.rpm
|
||||
devdeps-mariadb-connector-c-3.1.12-12022100422.el8.aarch64.rpm
|
||||
devdeps-libaio-0.3.112-12022092915.el8.aarch64.rpm
|
||||
devdeps-rapidjson-1.1.0-12022100410.el8.aarch64.rpm
|
||||
|
||||
2
deps/oblib/src/CMakeLists.txt
vendored
2
deps/oblib/src/CMakeLists.txt
vendored
@ -121,7 +121,7 @@ target_link_libraries(oblib_base_base_base
|
||||
${DEP_DIR}/lib/libssl.a
|
||||
${DEP_DIR}/lib/libcrypto.a
|
||||
${LGPL_DEPS}
|
||||
${DEP_DIR}/lib/libunwind.a
|
||||
$<$<STREQUAL:"${ARCHITECTURE}","x86_64">:${DEP_DIR}/lib/libunwind.a>
|
||||
${DEP_DIR}/lib/libz.a
|
||||
-L${DEP_DIR}/var/usr/lib64
|
||||
-L${DEP_DIR}/var/usr/lib
|
||||
|
||||
15
deps/oblib/src/lib/hash/ob_array_hash_map.h
vendored
15
deps/oblib/src/lib/hash/ob_array_hash_map.h
vendored
@ -119,21 +119,6 @@ public:
|
||||
size_ = 0;
|
||||
}
|
||||
|
||||
int shrink_size(int64_t size)
|
||||
{
|
||||
LockGuard guard(lock_);
|
||||
int ret = OB_SUCCESS;
|
||||
if (size <= 0 || size > capacity_) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
COMMON_LOG(WARN, "invalid argument", K(size), K_(capacity));
|
||||
} else if (size * 2 <= capacity_) {
|
||||
capacity_ = size * 2;
|
||||
} else {
|
||||
capacity_ = size;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void print() const
|
||||
{
|
||||
COMMON_LOG(INFO, "array_hash dump begin:", K(this));
|
||||
|
||||
307
deps/oblib/src/lib/hash/ob_ext_iter_hashset.h
vendored
307
deps/oblib/src/lib/hash/ob_ext_iter_hashset.h
vendored
@ -1,307 +0,0 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef OCEANBASE_LIB_HASH_OB_EXT_ITER_HASHSET_H__
|
||||
#define OCEANBASE_LIB_HASH_OB_EXT_ITER_HASHSET_H__
|
||||
|
||||
#include "lib/hash/ob_iteratable_hashset.h" // ObIteratableHashSet
|
||||
#include "lib/utility/ob_print_utils.h"
|
||||
|
||||
namespace oceanbase
|
||||
{
|
||||
namespace common
|
||||
{
|
||||
namespace hash
|
||||
{
|
||||
template <class K, uint64_t N, class Allocator> class ObExtIterHashSet;
|
||||
|
||||
///////////////////////////////////// ObExtIterHashSet Iterator /////////////////////////////////////
|
||||
template <class HashSet>
|
||||
class ObExtIterHashSetConstIterator
|
||||
{
|
||||
public:
|
||||
typedef typename HashSet::const_key_ref_t const_key_ref_t;
|
||||
typedef ObExtIterHashSetConstIterator<HashSet> SelfType;
|
||||
typedef typename HashSet::HashSetBucket BucketType;
|
||||
typedef typename HashSet::InnerHashSetIter InnerIter;
|
||||
|
||||
public:
|
||||
ObExtIterHashSetConstIterator(const HashSet *set, const BucketType *bucket, const InnerIter &iter)
|
||||
: hash_set_(set), bucket_(bucket), iter_(iter)
|
||||
{}
|
||||
|
||||
ObExtIterHashSetConstIterator(const SelfType &other)
|
||||
: hash_set_(other.hash_set_), bucket_(other.bucket_), iter_(other.iter_)
|
||||
{}
|
||||
|
||||
~ObExtIterHashSetConstIterator()
|
||||
{}
|
||||
|
||||
public:
|
||||
ObExtIterHashSetConstIterator &operator=(const SelfType &other)
|
||||
{
|
||||
if (this != &other) {
|
||||
hash_set_ = other.hash_set_;
|
||||
bucket_ = other.bucket_;
|
||||
iter_ = other.iter_;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
ObExtIterHashSetConstIterator &operator=(SelfType &&other) = default;
|
||||
|
||||
bool operator==(const SelfType &other) const
|
||||
{
|
||||
return other.hash_set_ == hash_set_ && other.bucket_ == bucket_ && other.iter_ == iter_;
|
||||
}
|
||||
|
||||
bool operator!=(const SelfType &other) const
|
||||
{
|
||||
return other.hash_set_ != hash_set_ || other.bucket_ != bucket_ || other.iter_ != iter_;
|
||||
}
|
||||
|
||||
SelfType &operator++()
|
||||
{
|
||||
if (NULL == hash_set_ || NULL == bucket_) {
|
||||
LIB_LOG(ERROR, "err hash set, iter or bucket", K(hash_set_), K(bucket_));
|
||||
} else {
|
||||
// if current bucket is not null, fetch next one.
|
||||
if (iter_ != bucket_->hash_set_.end()) {
|
||||
++iter_;
|
||||
}
|
||||
|
||||
// if reach end of current bucket, step to the next bucket.
|
||||
if (iter_ == bucket_->hash_set_.end() && NULL != bucket_->next_) {
|
||||
bucket_ = bucket_->next_;
|
||||
iter_ = bucket_->hash_set_.begin();
|
||||
}
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
const_key_ref_t operator*() const
|
||||
{
|
||||
if (NULL == hash_set_ || NULL == bucket_) {
|
||||
LIB_LOG(ERROR, "err hash set, iter or bucket", K(hash_set_), K(bucket_));
|
||||
}
|
||||
return *iter_;
|
||||
}
|
||||
|
||||
private:
|
||||
const HashSet *hash_set_;
|
||||
const BucketType *bucket_;
|
||||
InnerIter iter_;
|
||||
};
|
||||
|
||||
///////////////////////////////////// ObExtIterHashSet /////////////////////////////////////
|
||||
|
||||
template <class K, uint64_t N = 1031, class Allocator = ObIAllocator>
|
||||
class ObExtIterHashSet
|
||||
{
|
||||
public:
|
||||
typedef const K &const_key_ref_t;
|
||||
typedef ObIteratableHashSet<K, N> BaseHashSet;
|
||||
typedef ObExtIterHashSet<K, N, Allocator> SelfType;
|
||||
typedef ObExtIterHashSetConstIterator<SelfType> const_iterator_t;
|
||||
typedef typename BaseHashSet::const_iterator_t InnerHashSetIter;
|
||||
|
||||
struct HashSetBucket
|
||||
{
|
||||
BaseHashSet hash_set_;
|
||||
HashSetBucket *next_;
|
||||
|
||||
HashSetBucket() : hash_set_(), next_(NULL) {}
|
||||
~HashSetBucket() {}
|
||||
void reset()
|
||||
{
|
||||
hash_set_.reset();
|
||||
next_ = NULL;
|
||||
}
|
||||
};
|
||||
|
||||
public:
|
||||
explicit ObExtIterHashSet(Allocator &allocator);
|
||||
virtual ~ObExtIterHashSet();
|
||||
|
||||
public:
|
||||
/**
|
||||
* @retval OB_SUCCESS insert successfully
|
||||
* @retval OB_HASH_EXIST key exists
|
||||
* @retval other ret failed
|
||||
*/
|
||||
int set_refactored(const K &key);
|
||||
/**
|
||||
* @retval OB_HASH_EXIST key exists
|
||||
* @retval OB_HASH_NOT_EXIST key not exists
|
||||
*/
|
||||
int exist_refactored(const K &key) const { return is_exist_(key) ? OB_HASH_EXIST : OB_HASH_NOT_EXIST; }
|
||||
|
||||
void reset();
|
||||
void clear() { reset(); }
|
||||
|
||||
const_iterator_t begin() const
|
||||
{
|
||||
return const_iterator_t(this, &buckets_, buckets_.hash_set_.begin());
|
||||
}
|
||||
|
||||
const_iterator_t end() const
|
||||
{
|
||||
return const_iterator_t(this, buckets_tail_, buckets_tail_->hash_set_.end());
|
||||
}
|
||||
|
||||
int64_t count() const { return count_; }
|
||||
|
||||
public:
|
||||
DECLARE_TO_STRING;
|
||||
|
||||
private:
|
||||
bool is_exist_(const K &key) const;
|
||||
bool is_full_() const { return count_ >= bucket_num_ * static_cast<int64_t>(N); }
|
||||
int add_bucket_();
|
||||
|
||||
private:
|
||||
int64_t count_; // count of object
|
||||
int64_t bucket_num_; // count of bucket
|
||||
Allocator &allocator_; // allocator
|
||||
HashSetBucket buckets_; // bucket lists
|
||||
HashSetBucket *buckets_tail_; // bucket lists tail
|
||||
|
||||
private:
|
||||
template <class HashSet>
|
||||
friend class ObExtIterHashSetConstIterator;
|
||||
|
||||
private:
|
||||
DISALLOW_COPY_AND_ASSIGN(ObExtIterHashSet);
|
||||
};
|
||||
|
||||
template <class K, uint64_t N, class Allocator>
|
||||
ObExtIterHashSet<K, N, Allocator>::ObExtIterHashSet(Allocator &allocator) :
|
||||
count_(0),
|
||||
bucket_num_(1),
|
||||
allocator_(allocator),
|
||||
buckets_(),
|
||||
buckets_tail_(&buckets_)
|
||||
{}
|
||||
|
||||
template <class K, uint64_t N, class Allocator>
|
||||
ObExtIterHashSet<K, N, Allocator>::~ObExtIterHashSet()
|
||||
{
|
||||
reset();
|
||||
}
|
||||
|
||||
template <class K, uint64_t N, class Allocator>
|
||||
int ObExtIterHashSet<K, N, Allocator>::set_refactored(const K &key)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
bool exist = is_exist_(key);
|
||||
|
||||
if (exist) {
|
||||
ret = OB_HASH_EXIST;
|
||||
} else if (is_full_() && OB_FAIL(add_bucket_())) {
|
||||
LIB_LOG(WARN, "add_bucket_ fail", K(ret));
|
||||
} else {
|
||||
// keep inserting successful
|
||||
if (NULL == buckets_tail_) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LIB_LOG(WARN, "err bucket tail", K(ret));
|
||||
} else if (OB_FAIL(buckets_tail_->hash_set_.set_refactored(key))) {
|
||||
LIB_LOG(WARN, "set key into hash set fail", K(ret));
|
||||
} else {
|
||||
count_++;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
template <class K, uint64_t N, class Allocator>
|
||||
bool ObExtIterHashSet<K, N, Allocator>::is_exist_(const K &key) const
|
||||
{
|
||||
bool exist = false;
|
||||
const HashSetBucket *item = &buckets_;
|
||||
|
||||
while (! exist && NULL != item) {
|
||||
if (OB_HASH_EXIST == item->hash_set_.exist_refactored(key)) {
|
||||
exist = true;
|
||||
break;
|
||||
} else {
|
||||
item = item->next_;
|
||||
}
|
||||
}
|
||||
|
||||
return exist;
|
||||
}
|
||||
|
||||
template <class K, uint64_t N, class Allocator>
|
||||
int ObExtIterHashSet<K, N, Allocator>::add_bucket_()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
HashSetBucket *bucket = (HashSetBucket *)allocator_.alloc(sizeof(HashSetBucket));
|
||||
if (NULL == bucket) {
|
||||
LIB_LOG(WARN, "allocate memory for bucket fail", "bucket_size", sizeof(HashSetBucket));
|
||||
ret = OB_ALLOCATE_MEMORY_FAILED;
|
||||
} else {
|
||||
new(bucket) HashSetBucket();
|
||||
|
||||
bucket->next_ = NULL;
|
||||
buckets_tail_->next_ = bucket;
|
||||
buckets_tail_ = bucket;
|
||||
|
||||
bucket_num_++;
|
||||
|
||||
LIB_LOG(DEBUG, "add bucket", K(bucket_num_), K(count_), K(bucket));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
template <class K, uint64_t N, class Allocator>
|
||||
void ObExtIterHashSet<K, N, Allocator>::reset()
|
||||
{
|
||||
HashSetBucket *bucket = buckets_.next_;
|
||||
|
||||
while (NULL != bucket) {
|
||||
HashSetBucket *next = bucket->next_;
|
||||
bucket->~HashSetBucket();
|
||||
allocator_.free((void*)bucket);
|
||||
|
||||
bucket = next;
|
||||
}
|
||||
bucket = NULL;
|
||||
|
||||
buckets_.reset();
|
||||
buckets_tail_ = &buckets_;
|
||||
bucket_num_ = 1;
|
||||
count_ = 0;
|
||||
}
|
||||
|
||||
template <class K, uint64_t N, class Allocator>
|
||||
int64_t ObExtIterHashSet<K, N, Allocator>::to_string(char *buf, const int64_t buf_len) const
|
||||
{
|
||||
int64_t pos = 0;
|
||||
J_ARRAY_START();
|
||||
const_iterator_t beg = begin();
|
||||
for (const_iterator_t it = beg;
|
||||
it != end();
|
||||
++it) {
|
||||
if (it != beg) {
|
||||
J_COMMA();
|
||||
}
|
||||
BUF_PRINTO(*it);
|
||||
}
|
||||
J_ARRAY_END();
|
||||
return pos;
|
||||
}
|
||||
} // namespace hash
|
||||
} // namespace common
|
||||
} // namespace oceanbase
|
||||
#endif
|
||||
164
deps/oblib/src/lib/hash/ob_fixed_hash.h
vendored
164
deps/oblib/src/lib/hash/ob_fixed_hash.h
vendored
@ -1,164 +0,0 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef OCEANBASE_HASH_OB_FIXED_HASH_H_
|
||||
#define OCEANBASE_HASH_OB_FIXED_HASH_H_
|
||||
|
||||
#include "lib/ob_define.h"
|
||||
#include "lib/queue/ob_link.h"
|
||||
#include "lib/hash/ob_hash.h"
|
||||
|
||||
namespace oceanbase
|
||||
{
|
||||
namespace common
|
||||
{
|
||||
template<typename key_t>
|
||||
class FixedHash
|
||||
{
|
||||
public:
|
||||
typedef ObLink Link;
|
||||
struct node_t: public Link
|
||||
{
|
||||
node_t(): hash_(0), key_() {}
|
||||
explicit node_t(key_t key): key_(key) {
|
||||
hash_ = hash_map_calc_hash(key_);
|
||||
}
|
||||
~node_t() {}
|
||||
static uint64_t hash_map_calc_hash(key_t key)
|
||||
{
|
||||
return calc_hash(key) | 1;
|
||||
}
|
||||
|
||||
node_t* set(key_t key)
|
||||
{
|
||||
hash_ = hash_map_calc_hash(key);
|
||||
key_ = key;
|
||||
return this;
|
||||
}
|
||||
|
||||
bool is_dummy_node() {
|
||||
return 0 == (hash_ & 1);
|
||||
}
|
||||
|
||||
int compare(node_t* that)
|
||||
{
|
||||
int ret = 0;
|
||||
if (this->hash_ > that->hash_) {
|
||||
ret = 1;
|
||||
} else if (this->hash_ < that->hash_) {
|
||||
ret = -1;
|
||||
} else if (this->is_dummy_node()) {
|
||||
ret = 0;
|
||||
} else {
|
||||
ret = common::compare(this->key_, that->key_);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
node_t* set_as_bucket(uint64_t idx)
|
||||
{
|
||||
hash_ = bitrev(idx);
|
||||
return this;
|
||||
}
|
||||
|
||||
uint64_t get_spk() { return bitrev(hash_); }
|
||||
uint64_t hash_;
|
||||
key_t key_;
|
||||
};
|
||||
|
||||
FixedHash(void* buf, int64_t size):
|
||||
nodes_((node_t*)buf), limit_(last2n(size/sizeof(node_t))) {
|
||||
init_buckets(nodes_, limit_);
|
||||
}
|
||||
~FixedHash() {}
|
||||
|
||||
int insert(key_t key, node_t* node) {
|
||||
node_t key_node(key);
|
||||
return ol_insert(get_pre(&key_node), node->set(key));
|
||||
}
|
||||
|
||||
int del(key_t key, node_t*& node) {
|
||||
node_t key_node(key);
|
||||
return ol_del(get_pre(&key_node), &key_node, node);
|
||||
}
|
||||
|
||||
int get(key_t key, node_t*& node) {
|
||||
node_t key_node(key);
|
||||
return ol_get(get_pre(&key_node), &key_node, node);
|
||||
}
|
||||
|
||||
node_t* next(node_t* node) {
|
||||
while(NULL != (node = next_node(node))
|
||||
&& node->is_dummy_node())
|
||||
;
|
||||
return node;
|
||||
}
|
||||
private:
|
||||
node_t* next_node(node_t* node) {
|
||||
node_t* next = NULL;
|
||||
if (NULL == node) {
|
||||
next = nodes_;
|
||||
} else if (is_last_bit_set((uint64_t)(next = (node_t*)ATOMIC_LOAD(&node->next_)))) {
|
||||
next = get_pre(node);
|
||||
}
|
||||
return next;
|
||||
}
|
||||
|
||||
static uint64_t last2n(const uint64_t x)
|
||||
{
|
||||
return x == 0? 0 : (1UL << 63) >> (__builtin_clzll(x));
|
||||
}
|
||||
|
||||
static uint64_t bitrev(uint64_t x)
|
||||
{
|
||||
x = (((x & 0xaaaaaaaaaaaaaaaaUL) >> 1) | ((x & 0x5555555555555555UL) << 1));
|
||||
x = (((x & 0xccccccccccccccccUL) >> 2) | ((x & 0x3333333333333333UL) << 2));
|
||||
x = (((x & 0xf0f0f0f0f0f0f0f0UL) >> 4) | ((x & 0x0f0f0f0f0f0f0f0fUL) << 4));
|
||||
x = (((x & 0xff00ff00ff00ff00UL) >> 8) | ((x & 0x00ff00ff00ff00ffUL) << 8));
|
||||
x = (((x & 0xffff0000ffff0000UL) >> 16) | ((x & 0x0000ffff0000ffff) << 16));
|
||||
return((x >> 32) | (x << 32));
|
||||
}
|
||||
|
||||
static uint64_t get_idx(uint64_t spk, uint64_t bcnt)
|
||||
{
|
||||
return bcnt == 0? 0 : (spk & (bcnt - 1));
|
||||
}
|
||||
|
||||
node_t* get_pre(node_t* key_node)
|
||||
{
|
||||
return nodes_ + get_idx(key_node->get_spk(), limit_);
|
||||
}
|
||||
|
||||
static uint64_t get_bucket_pre_idx(uint64_t idx) {
|
||||
return idx & ~last2n(idx);
|
||||
}
|
||||
|
||||
static int init_buckets(node_t* nodes, int64_t limit) {
|
||||
int err = 0;
|
||||
new(nodes)node_t[limit];
|
||||
nodes[0].set_as_bucket(0);
|
||||
for(int64_t i = 1; 0 == err && i < limit; i++) {
|
||||
node_t* node = nodes + i;
|
||||
node->set_as_bucket(i);
|
||||
err = ol_insert(nodes + get_bucket_pre_idx(i), node);
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
private:
|
||||
node_t* nodes_;
|
||||
int64_t limit_;
|
||||
};
|
||||
|
||||
}; // end namespace common
|
||||
}; // end namespace oceanbase
|
||||
#endif /* OCEANBASE_HASH_OB_FIXED_HASH_H_ */
|
||||
379
deps/oblib/src/lib/hash/ob_pre_alloc_link_hashmap.h
vendored
379
deps/oblib/src/lib/hash/ob_pre_alloc_link_hashmap.h
vendored
@ -1,379 +0,0 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef SRC_LIBRARY_SRC_LIB_HASH_OB_MEMLESS_LINK_HASHMAP_H_
|
||||
#define SRC_LIBRARY_SRC_LIB_HASH_OB_MEMLESS_LINK_HASHMAP_H_
|
||||
|
||||
#include "lib/ob_define.h"
|
||||
#include "lib/hash/ob_hashutils.h"
|
||||
#include "lib/atomic/ob_atomic.h"
|
||||
#include "lib/utility/ob_print_utils.h"
|
||||
#include "lib/container/ob_array.h"
|
||||
#include "lib/lock/ob_bucket_lock.h"
|
||||
|
||||
namespace oceanbase
|
||||
{
|
||||
namespace common
|
||||
{
|
||||
namespace hash
|
||||
{
|
||||
|
||||
// ObMemLessLinkHashMap is convenient for reuse of node.
|
||||
// there is a simple allocator in the map.
|
||||
// memory of node should be pre-allocated.
|
||||
// use of storage of table and meta block.
|
||||
template <class KEY, class ITEM>
|
||||
struct ObPreAllocLinkHashNode
|
||||
{
|
||||
explicit ObPreAllocLinkHashNode(ITEM &item): item_(item) {}
|
||||
virtual ~ObPreAllocLinkHashNode() { }
|
||||
virtual OB_INLINE bool equals(const ObPreAllocLinkHashNode &node) { return equals(node.get_key()); }
|
||||
virtual OB_INLINE bool equals(const KEY &key) { return get_key() == key; }
|
||||
//derived class should override static uint64_t hash(const uint64_t &key);
|
||||
|
||||
virtual const KEY &get_key() const = 0;
|
||||
VIRTUAL_TO_STRING_KV(KP(this), K_(item));
|
||||
|
||||
ITEM &item_;
|
||||
};
|
||||
|
||||
template <class KEY, class ITEM, class NODE, class ITEM_PROTECTOR>
|
||||
class ObPreAllocLinkHashMap
|
||||
{
|
||||
public:
|
||||
class ForeachFunctor
|
||||
{
|
||||
public:
|
||||
virtual int operator()(ITEM &item, bool &is_full) = 0;
|
||||
};
|
||||
|
||||
class EraseChecker
|
||||
{
|
||||
public:
|
||||
virtual int operator()(ITEM &item) = 0;
|
||||
};
|
||||
|
||||
class GetFunctor
|
||||
{
|
||||
public:
|
||||
virtual int operator()(ITEM &item) = 0;
|
||||
};
|
||||
|
||||
class Iterator
|
||||
{
|
||||
public:
|
||||
explicit Iterator(ObPreAllocLinkHashMap &map)
|
||||
: items_(),
|
||||
item_idx_(0),
|
||||
bucket_pos_(0),
|
||||
map_(map)
|
||||
{
|
||||
}
|
||||
virtual ~Iterator() { release_items(); }
|
||||
int get_next(ITEM *&item)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
item = NULL;
|
||||
|
||||
while (OB_SUCC(ret)) {
|
||||
if (item_idx_ < items_.count()) {
|
||||
item = items_.at(item_idx_);
|
||||
++item_idx_;
|
||||
break;
|
||||
} else if (bucket_pos_ >= map_.buckets_count_) {
|
||||
ret = OB_ITER_END;
|
||||
} else {
|
||||
item_idx_ = 0;
|
||||
release_items();
|
||||
ObBucketRLockGuard guard(map_.buckets_lock_, bucket_pos_);
|
||||
if (NULL != map_.buckets_[bucket_pos_]) {
|
||||
NODE *node = map_.buckets_[bucket_pos_];
|
||||
while (OB_SUCC(ret) && NULL != node) {
|
||||
ITEM_PROTECTOR::hold(node->item_);
|
||||
if (OB_FAIL(items_.push_back(&node->item_))) {
|
||||
COMMON_LOG(WARN, "Failed to add item", K(ret));
|
||||
ITEM_PROTECTOR::release(node->item_);
|
||||
} else {
|
||||
node = node->next_;
|
||||
}
|
||||
}
|
||||
}
|
||||
++bucket_pos_;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
private:
|
||||
void release_items()
|
||||
{
|
||||
for (int64_t i = 0; i < items_.count(); ++i) {
|
||||
ITEM_PROTECTOR::release(*items_.at(i));
|
||||
}
|
||||
items_.reuse();
|
||||
}
|
||||
common::ObArray<ITEM *> items_;
|
||||
int64_t item_idx_;
|
||||
int64_t bucket_pos_;
|
||||
ObPreAllocLinkHashMap &map_;
|
||||
DISALLOW_COPY_AND_ASSIGN(Iterator);
|
||||
};
|
||||
|
||||
ObPreAllocLinkHashMap()
|
||||
: is_inited_(false),
|
||||
buckets_lock_(),
|
||||
count_(),
|
||||
buckets_(NULL),
|
||||
buckets_count_(1),
|
||||
allocator_()
|
||||
{
|
||||
}
|
||||
virtual ~ObPreAllocLinkHashMap()
|
||||
{
|
||||
destroy();
|
||||
}
|
||||
|
||||
void destroy()
|
||||
{
|
||||
for (uint64_t bucket_pos = 0; NULL != buckets_ && bucket_pos < buckets_count_; ++bucket_pos) {
|
||||
ObBucketRLockGuard bucket_guard(buckets_lock_, bucket_pos);
|
||||
NODE *cur = buckets_[bucket_pos];
|
||||
NODE *next = NULL;
|
||||
while (NULL != cur) {
|
||||
next = cur->next_;
|
||||
free_node(cur);
|
||||
cur = next;
|
||||
}
|
||||
}
|
||||
is_inited_ = false;
|
||||
buckets_lock_.destroy();
|
||||
count_ = 0;
|
||||
ob_free(buckets_);
|
||||
buckets_ = NULL;
|
||||
buckets_count_ = 1;
|
||||
}
|
||||
|
||||
int init(const int64_t buckets_count, const uint32_t latch_id, const lib::ObLabel &label)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObMemAttr mem_attr(OB_SERVER_TENANT_ID, label);
|
||||
const int64_t real_buckets_count = hash::cal_next_prime(buckets_count);
|
||||
|
||||
if (is_inited_) {
|
||||
ret = OB_INIT_TWICE;
|
||||
COMMON_LOG(WARN, "cannot init twice", K(ret));
|
||||
} else if (real_buckets_count <= 0 || buckets_count <= 0) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
COMMON_LOG(WARN, "invalid bucket count", K(ret), K(real_buckets_count), K(buckets_count));
|
||||
} else if (OB_FAIL(buckets_lock_.init(real_buckets_count, latch_id, label))) {
|
||||
COMMON_LOG(WARN, "failed to init buckets lock", K(ret));
|
||||
} else if (OB_ISNULL(buckets_ = reinterpret_cast<NODE**>(
|
||||
ob_malloc(sizeof(NODE*) * real_buckets_count, mem_attr)))) {
|
||||
ret = OB_ALLOCATE_MEMORY_FAILED;
|
||||
COMMON_LOG(WARN, "failed to alloc buckets", K(ret), K(real_buckets_count));
|
||||
} else {
|
||||
allocator_.set_label(label);
|
||||
MEMSET(buckets_, 0, sizeof(NODE*) * real_buckets_count);
|
||||
COMMON_LOG(INFO, "init hashmap", K(buckets_count), K(real_buckets_count),
|
||||
"buf_size", sizeof(NODE*) * real_buckets_count, K(latch_id), K(label));
|
||||
count_ = 0;
|
||||
buckets_count_ = real_buckets_count;
|
||||
is_inited_ = true;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint64_t get_count() const { return ATOMIC_LOAD(&count_); }
|
||||
uint64_t get_buckets_count() const { return buckets_count_; }
|
||||
|
||||
NODE *alloc_node(ITEM &item)
|
||||
{
|
||||
return allocator_.alloc(item);
|
||||
}
|
||||
|
||||
void free_node(NODE *&node)
|
||||
{
|
||||
allocator_.free(node);
|
||||
node = NULL;
|
||||
}
|
||||
|
||||
int put(NODE &node)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
|
||||
if (!is_inited_) {
|
||||
ret = OB_NOT_INIT;
|
||||
COMMON_LOG(WARN, "not inited", K(ret));
|
||||
} else {
|
||||
const uint64_t bucket_pos = NODE::hash(node.get_key()) % buckets_count_;
|
||||
ObBucketWLockGuard bucket_guard(buckets_lock_, bucket_pos);
|
||||
NODE *cur = buckets_[bucket_pos];
|
||||
while (NULL != cur) {
|
||||
if (cur->equals(node)) {
|
||||
break;
|
||||
} else {
|
||||
cur = cur->next_;
|
||||
}
|
||||
}
|
||||
|
||||
if (NULL != cur) {
|
||||
ret = OB_HASH_EXIST;
|
||||
} else {
|
||||
node.next_ = buckets_[bucket_pos];
|
||||
buckets_[bucket_pos] = &node;
|
||||
ATOMIC_INC(&count_);
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
// delete node which has common key
|
||||
int erase(const KEY &key, ITEM *&del_item, EraseChecker *checker = NULL)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
del_item = NULL;
|
||||
|
||||
if (!is_inited_) {
|
||||
ret = OB_NOT_INIT;
|
||||
COMMON_LOG(WARN, "not inited", K(ret));
|
||||
} else {
|
||||
const uint64_t bucket_pos = NODE::hash(key) % buckets_count_;
|
||||
ObBucketWLockGuard bucket_guard(buckets_lock_, bucket_pos);
|
||||
NODE *cur = buckets_[bucket_pos];
|
||||
NODE *prev = NULL;
|
||||
while (NULL != cur) {
|
||||
if (cur->equals(key)) {
|
||||
break;
|
||||
} else {
|
||||
prev = cur;
|
||||
cur = cur->next_;
|
||||
}
|
||||
}
|
||||
|
||||
if (NULL == cur) {
|
||||
ret = OB_HASH_NOT_EXIST;
|
||||
} else if (NULL != checker && OB_FAIL((*checker)(cur->item_))) {
|
||||
// cannot erase now
|
||||
} else {
|
||||
if (NULL != prev) {
|
||||
prev->next_ = cur->next_;
|
||||
} else {
|
||||
buckets_[bucket_pos] = cur->next_;
|
||||
}
|
||||
cur->next_ = NULL;
|
||||
del_item = &cur->item_;
|
||||
free_node(cur);
|
||||
ATOMIC_DEC(&count_);
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
// delete node which has common key
|
||||
int erase(const KEY &key)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ITEM *del_item = NULL;
|
||||
if (OB_FAIL(erase(key, del_item))) {
|
||||
COMMON_LOG(WARN, "failed to erase ndoe", K(ret), K(key));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int exist(const KEY &key)
|
||||
{
|
||||
ITEM *item = NULL;
|
||||
int ret = get(key, item);
|
||||
if (OB_SUCCESS == ret) {
|
||||
ret = OB_HASH_EXIST;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int get(const KEY &key, GetFunctor &functor)
|
||||
{
|
||||
ITEM *item = NULL;
|
||||
return get(key, item, &functor);
|
||||
}
|
||||
|
||||
int get(const KEY &key, ITEM *&item, GetFunctor *functor = NULL)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
item = NULL;
|
||||
|
||||
if (!is_inited_) {
|
||||
ret = OB_NOT_INIT;
|
||||
COMMON_LOG(WARN, "not inited", K(ret));
|
||||
} else {
|
||||
const uint64_t bucket_pos = NODE::hash(key) % buckets_count_;
|
||||
ObBucketRLockGuard bucket_guard(buckets_lock_, bucket_pos);
|
||||
NODE *cur = buckets_[bucket_pos];
|
||||
while (NULL != cur) {
|
||||
if (cur->equals(key)) {
|
||||
break;
|
||||
} else {
|
||||
cur = cur->next_;
|
||||
}
|
||||
}
|
||||
|
||||
if (NULL == cur) {
|
||||
ret = OB_HASH_NOT_EXIST;
|
||||
} else if (NULL != functor && OB_FAIL((*functor)(cur->item_))) {
|
||||
COMMON_LOG(WARN, "failed to do get functor", K(ret), K(*cur));
|
||||
} else {
|
||||
item = &cur->item_;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int foreach(ForeachFunctor &functor)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
bool is_full = false;
|
||||
|
||||
if (!is_inited_) {
|
||||
ret = OB_NOT_INIT;
|
||||
COMMON_LOG(WARN, "not inited", K(ret));
|
||||
} else {
|
||||
for (uint64_t bucket_pos = 0; OB_SUCC(ret) && !is_full && bucket_pos < buckets_count_; ++bucket_pos) {
|
||||
ObBucketRLockGuard bucket_guard(buckets_lock_, bucket_pos);
|
||||
NODE *cur = buckets_[bucket_pos];
|
||||
while (OB_SUCC(ret) && NULL != cur && !is_full) {
|
||||
if (OB_FAIL(functor(cur->item_, is_full))) {
|
||||
COMMON_LOG(WARN, "failed to do foreach functor", K(ret));
|
||||
} else {
|
||||
cur = cur->next_;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
private:
|
||||
bool is_inited_;
|
||||
mutable common::ObBucketLock buckets_lock_;
|
||||
uint64_t count_;
|
||||
NODE **buckets_;
|
||||
uint64_t buckets_count_;
|
||||
SimpleAllocer<NODE> allocator_;
|
||||
DISALLOW_COPY_AND_ASSIGN(ObPreAllocLinkHashMap);
|
||||
};
|
||||
|
||||
|
||||
} // hash
|
||||
} // common
|
||||
} // oceanbase
|
||||
#endif /* SRC_LIBRARY_SRC_LIB_HASH_OB_MEMLESS_LINK_HASHMAP_H_ */
|
||||
2
deps/oblib/src/lib/signal/ob_libunwind.c
vendored
2
deps/oblib/src/lib/signal/ob_libunwind.c
vendored
@ -10,6 +10,7 @@
|
||||
* See the Mulan PubL v2 for more details.
|
||||
*/
|
||||
|
||||
#ifdef __x86_64__
|
||||
#include "lib/signal/ob_libunwind.h"
|
||||
#include "lib/signal/safe_snprintf.h"
|
||||
#define UNW_LOCAL_ONLY
|
||||
@ -106,3 +107,4 @@ int8_t get_frame_info(unw_cursor_t *cursor, uintptr_t *ip)
|
||||
*ip = uip - (r == 0);
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -157,7 +157,9 @@ void coredump_cb(int sig, siginfo_t *si, void *context)
|
||||
// backtrace
|
||||
char bt[256];
|
||||
int64_t len = 0;
|
||||
#ifdef __x86_64__
|
||||
safe_backtrace(bt, sizeof(bt) - 1, &len);
|
||||
#endif
|
||||
bt[len++] = '\0';
|
||||
// extra
|
||||
const ObFatalErrExtraInfoGuard *extra_info = nullptr; // TODO: May deadlock, ObFatalErrExtraInfoGuard::get_thd_local_val_ptr();
|
||||
|
||||
@ -65,7 +65,9 @@ int ObSigBTOnlyProcessor::prepare()
|
||||
int64_t count = 0;
|
||||
count = safe_snprintf(buf_ + pos_, len - pos_, "tid: %ld, tname: %s, lbt: ", tid, tname);
|
||||
pos_ += count;
|
||||
#ifdef __x86_64__
|
||||
safe_backtrace(buf_ + pos_, len - pos_, &count);
|
||||
#endif
|
||||
pos_ += count;
|
||||
buf_[pos_++] = '\n';
|
||||
return ret;
|
||||
|
||||
@ -44,7 +44,9 @@ void crash_restore_handler(int sig, siginfo_t *s, void *p)
|
||||
if (SIGSEGV == sig || SIGABRT == sig ||
|
||||
SIGBUS == sig || SIGFPE == sig) {
|
||||
int64_t len = 0;
|
||||
#ifdef __x86_64__
|
||||
safe_backtrace(crash_restore_buffer, 255, &len);
|
||||
#endif
|
||||
crash_restore_buffer[len++] = '\0';
|
||||
siglongjmp(*g_jmp, 1);
|
||||
} else {
|
||||
|
||||
@ -33,6 +33,7 @@ bool g_inited = false;
|
||||
int send_request_and_wait(ObSigRequestCode code, int exclude_tid)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
#ifdef __x86_64__
|
||||
DTraceId trace_id = DTraceId::gen_trace_id();
|
||||
DTraceIdGuard trace_guard(trace_id);
|
||||
ObSigRequest req;
|
||||
@ -93,6 +94,7 @@ int send_request_and_wait(ObSigRequestCode code, int exclude_tid)
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
2
deps/oblib/unittest/lib/CMakeLists.txt
vendored
2
deps/oblib/unittest/lib/CMakeLists.txt
vendored
@ -47,7 +47,6 @@ oblib_addtest(hash/test_array_index_hash_set.cpp)
|
||||
oblib_addtest(hash/test_build_in_hashmap.cpp)
|
||||
oblib_addtest(hash/test_concurrent_hash_map.cpp)
|
||||
oblib_addtest(hash/test_cuckoo_hashmap.cpp)
|
||||
oblib_addtest(hash/test_ext_iter_hashset.cpp)
|
||||
oblib_addtest(hash/test_hashmap.cpp)
|
||||
oblib_addtest(hash/test_fnv_hash.cpp)
|
||||
oblib_addtest(hash/test_hashset.cpp)
|
||||
@ -57,7 +56,6 @@ oblib_addtest(hash/test_link_hashmap.cpp)
|
||||
oblib_addtest(hash/test_linear_hash_map.cpp)
|
||||
oblib_addtest(hash/test_placement_hashset.cpp)
|
||||
oblib_addtest(hash/test_pointer_hashmap.cpp)
|
||||
oblib_addtest(hash/test_pre_alloc_link_hashmap.cpp)
|
||||
oblib_addtest(hash/test_simpleallocer.cpp)
|
||||
oblib_addtest(json/test_json_print_utils.cpp)
|
||||
oblib_addtest(json/test_yson.cpp)
|
||||
|
||||
@ -1,360 +0,0 @@
|
||||
/**
|
||||
* 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 "lib/hash/ob_ext_iter_hashset.h"
|
||||
#include "lib/allocator/ob_malloc.h"
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
using namespace oceanbase::common;
|
||||
using namespace oceanbase::common::hash;
|
||||
class ObExtIterHashSetTest: public ::testing::Test
|
||||
{
|
||||
public:
|
||||
ObExtIterHashSetTest();
|
||||
virtual ~ObExtIterHashSetTest();
|
||||
virtual void SetUp();
|
||||
virtual void TearDown();
|
||||
|
||||
public:
|
||||
ObArenaAllocator allocator_;
|
||||
|
||||
private:
|
||||
// disallow copy
|
||||
ObExtIterHashSetTest(const ObExtIterHashSetTest &other);
|
||||
ObExtIterHashSetTest& operator=(const ObExtIterHashSetTest &other);
|
||||
protected:
|
||||
// data members
|
||||
};
|
||||
|
||||
ObExtIterHashSetTest::ObExtIterHashSetTest() : allocator_(ObModIds::TEST)
|
||||
{
|
||||
}
|
||||
|
||||
ObExtIterHashSetTest::~ObExtIterHashSetTest()
|
||||
{
|
||||
}
|
||||
|
||||
void ObExtIterHashSetTest::SetUp()
|
||||
{
|
||||
}
|
||||
|
||||
void ObExtIterHashSetTest::TearDown()
|
||||
{
|
||||
allocator_.reset();
|
||||
}
|
||||
|
||||
TEST_F(ObExtIterHashSetTest, basic_test)
|
||||
{
|
||||
static const int64_t N = 256;
|
||||
static const int64_t BUCKET_NUM = 8;
|
||||
ObExtIterHashSet<int64_t, N> set(allocator_);
|
||||
for (int round = 0; round < 5; ++round) {
|
||||
ASSERT_EQ(0, set.count());
|
||||
ASSERT_EQ(set.begin(), set.end());
|
||||
ASSERT_EQ(++(set.begin()), set.end());
|
||||
|
||||
// insert data
|
||||
for (int64_t index = 0; index < N * BUCKET_NUM; index++) {
|
||||
int64_t value = index + 1;
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, set.exist_refactored(value));
|
||||
ASSERT_EQ(OB_SUCCESS, set.set_refactored(value));
|
||||
ASSERT_EQ(OB_HASH_EXIST, set.exist_refactored(value));
|
||||
ASSERT_EQ(index + 1, set.count());
|
||||
}
|
||||
|
||||
// verify data
|
||||
ObExtIterHashSet<int64_t, N>::const_iterator_t it = set.begin();
|
||||
for(int64_t value = 1; it != set.end(); ++it, value++) {
|
||||
ASSERT_EQ(value, *it);
|
||||
}
|
||||
set.clear();
|
||||
ASSERT_EQ(0, set.count());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(ObExtIterHashSetTest, single_N)
|
||||
{
|
||||
ObExtIterHashSet<int64_t, 1> hashset(allocator_);
|
||||
ObExtIterHashSet<int64_t, 1>::const_iterator_t iter = hashset.begin();
|
||||
ASSERT_EQ(iter, hashset.end());
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
|
||||
ASSERT_EQ(0, hashset.count());
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(1));
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(1));
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(1));
|
||||
ASSERT_EQ(1, hashset.count());
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(2));
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(2));
|
||||
ASSERT_EQ(2, hashset.count());
|
||||
|
||||
iter = hashset.begin();
|
||||
ASSERT_NE(iter, hashset.end());
|
||||
ASSERT_EQ(1, *iter);
|
||||
ASSERT_NE(++iter, hashset.end());
|
||||
ASSERT_EQ(2, *iter);
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
}
|
||||
|
||||
TEST_F(ObExtIterHashSetTest, many_N_single_bucket)
|
||||
{
|
||||
const uint64_t N = 10345;
|
||||
int64_t value = 0;
|
||||
ObExtIterHashSet<int64_t, N> hashset(allocator_);
|
||||
ObExtIterHashSet<int64_t, N>::const_iterator_t iter = hashset.begin();
|
||||
ASSERT_EQ(iter, hashset.end());
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
|
||||
for (uint64_t i = 0; i < N; i++) {
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < N; i++) {
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(i));
|
||||
}
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(N));
|
||||
|
||||
for (uint64_t i = 0; i < N; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < N; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(i));
|
||||
}
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(N));
|
||||
|
||||
for (uint64_t i = 0; i < N; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
|
||||
ASSERT_EQ(N + 1, hashset.count());
|
||||
for (value = 0, iter = hashset.begin(); iter != hashset.end(); ++iter, value++) {
|
||||
ASSERT_EQ(value, *iter);
|
||||
}
|
||||
|
||||
hashset.clear();
|
||||
|
||||
iter = hashset.begin();
|
||||
ASSERT_EQ(iter, hashset.end());
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
|
||||
for (uint64_t i = 0; i < N; i++) {
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < N; i++) {
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(i));
|
||||
}
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(N));
|
||||
for (uint64_t i = 0; i < N; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < N; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(i));
|
||||
}
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(N));
|
||||
for (uint64_t i = 0; i < N; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
|
||||
ASSERT_EQ(N + 1, hashset.count());
|
||||
for (value = 0, iter = hashset.begin(); iter != hashset.end(); ++iter, value++) {
|
||||
ASSERT_EQ(value, *iter);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(ObExtIterHashSetTest, many_N_single_buckets2)
|
||||
{
|
||||
const uint64_t N = 10345;
|
||||
int64_t value = 0;
|
||||
ObExtIterHashSet<int64_t, N> hashset(allocator_);
|
||||
ObExtIterHashSet<int64_t, N>::const_iterator_t iter = hashset.begin();
|
||||
ASSERT_EQ(iter, hashset.end());
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
|
||||
for (uint64_t i = N; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = N; i > 0; i--) {
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(i));
|
||||
}
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(0));
|
||||
for (uint64_t i = N; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = N; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(i));
|
||||
}
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(0));
|
||||
for (uint64_t i = N; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
|
||||
ASSERT_EQ(N + 1, hashset.count());
|
||||
for (value = N, iter = hashset.begin(); iter != hashset.end(); ++iter, value--) {
|
||||
ASSERT_EQ(value, *iter);
|
||||
}
|
||||
|
||||
hashset.clear();
|
||||
|
||||
iter = hashset.begin();
|
||||
ASSERT_EQ(iter, hashset.end());
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
|
||||
for (uint64_t i = N; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = N; i > 0; i--) {
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(i));
|
||||
}
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(0));
|
||||
for (uint64_t i = N; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = N; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(i));
|
||||
}
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(0));
|
||||
for (uint64_t i = N; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
|
||||
ASSERT_EQ(N + 1, hashset.count());
|
||||
for (value = N, iter = hashset.begin(); iter != hashset.end(); ++iter, value--) {
|
||||
ASSERT_EQ(value, *iter);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(ObExtIterHashSetTest, many_N_many_buckets)
|
||||
{
|
||||
static const uint64_t N = 16;
|
||||
static const uint64_t BUCKET_NUM = 100;
|
||||
static const uint64_t ELEMENT_NUM = N * BUCKET_NUM;
|
||||
int64_t value = 0;
|
||||
ObExtIterHashSet<int64_t, N> hashset(allocator_);
|
||||
ObExtIterHashSet<int64_t, N>::const_iterator_t iter = hashset.begin();
|
||||
ASSERT_EQ(iter, hashset.end());
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
|
||||
for (uint64_t i = 0; i < ELEMENT_NUM; i++) {
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < ELEMENT_NUM; i++) {
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < ELEMENT_NUM; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < ELEMENT_NUM; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < ELEMENT_NUM; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
|
||||
ASSERT_EQ(ELEMENT_NUM, hashset.count());
|
||||
for (value = 0, iter = hashset.begin(); iter != hashset.end(); ++iter, value++) {
|
||||
ASSERT_EQ(value, *iter);
|
||||
}
|
||||
|
||||
hashset.clear();
|
||||
|
||||
iter = hashset.begin();
|
||||
ASSERT_EQ(iter, hashset.end());
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
|
||||
for (uint64_t i = 0; i < ELEMENT_NUM; i++) {
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < ELEMENT_NUM; i++) {
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < ELEMENT_NUM; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < ELEMENT_NUM; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(i));
|
||||
}
|
||||
for (uint64_t i = 0; i < ELEMENT_NUM; i++) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
|
||||
ASSERT_EQ(ELEMENT_NUM, hashset.count());
|
||||
for (value = 0, iter = hashset.begin(); iter != hashset.end(); ++iter, value++) {
|
||||
ASSERT_EQ(value, *iter);
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(ObExtIterHashSetTest, many_N_many_buckets2)
|
||||
{
|
||||
static const uint64_t N = 128;
|
||||
static const uint64_t BUCKET_NUM = 10;
|
||||
static const uint64_t ELEMENT_NUM = N * BUCKET_NUM;
|
||||
int64_t value = 0;
|
||||
ObExtIterHashSet<int64_t, N> hashset(allocator_);
|
||||
ObExtIterHashSet<int64_t, N>::const_iterator_t iter = hashset.begin();
|
||||
ASSERT_EQ(iter, hashset.end());
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
|
||||
for (uint64_t i = ELEMENT_NUM; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = ELEMENT_NUM; i > 0; i--) {
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(i));
|
||||
}
|
||||
for (uint64_t i = ELEMENT_NUM; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = ELEMENT_NUM; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(i));
|
||||
}
|
||||
for (uint64_t i = ELEMENT_NUM; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
|
||||
ASSERT_EQ(ELEMENT_NUM, hashset.count());
|
||||
for (value = ELEMENT_NUM, iter = hashset.begin(); iter != hashset.end(); ++iter, value--) {
|
||||
ASSERT_EQ(value, *iter);
|
||||
}
|
||||
|
||||
hashset.clear();
|
||||
|
||||
iter = hashset.begin();
|
||||
ASSERT_EQ(iter, hashset.end());
|
||||
ASSERT_EQ(++iter, hashset.end());
|
||||
|
||||
for (uint64_t i = ELEMENT_NUM; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = ELEMENT_NUM; i > 0; i--) {
|
||||
ASSERT_EQ(OB_SUCCESS, hashset.set_refactored(i));
|
||||
}
|
||||
for (uint64_t i = ELEMENT_NUM; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
for (uint64_t i = ELEMENT_NUM; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.set_refactored(i));
|
||||
}
|
||||
for (uint64_t i = ELEMENT_NUM; i > 0; i--) {
|
||||
ASSERT_EQ(OB_HASH_EXIST, hashset.exist_refactored(i));
|
||||
}
|
||||
|
||||
ASSERT_EQ(ELEMENT_NUM, hashset.count());
|
||||
for (value = ELEMENT_NUM, iter = hashset.begin(); iter != hashset.end(); ++iter, value--) {
|
||||
ASSERT_EQ(value, *iter);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
OB_LOGGER.set_log_level("INFO");
|
||||
::testing::InitGoogleTest(&argc,argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
@ -1,373 +0,0 @@
|
||||
/**
|
||||
* 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 <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <sys/time.h>
|
||||
#include <unistd.h>
|
||||
#include "lib/hash/ob_pre_alloc_link_hashmap.h"
|
||||
#include "lib/allocator/ob_malloc.h"
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using namespace oceanbase;
|
||||
using namespace oceanbase::common;
|
||||
using namespace oceanbase::common::hash;
|
||||
|
||||
struct Item
|
||||
{
|
||||
int64_t key_;
|
||||
int64_t value_;
|
||||
int64_t ref_;
|
||||
|
||||
Item(): key_(0), value_(0), ref_(0) {}
|
||||
Item(const int64_t key, const int64_t value, const int64_t ref):
|
||||
key_(key), value_(value), ref_(ref) {}
|
||||
TO_STRING_KV(K_(key), K_(value));
|
||||
};
|
||||
|
||||
struct Node: public ObPreAllocLinkHashNode<int64_t, Item>
|
||||
{
|
||||
explicit Node(Item &item): ObPreAllocLinkHashNode(item), next_(NULL) {}
|
||||
virtual ~Node() { }
|
||||
static uint64_t hash(int64_t key) { return key; }
|
||||
virtual uint64_t hash() const { return hash(item_.key_); }
|
||||
virtual const int64_t &get_key() const { return item_.key_; }
|
||||
Node *next_;
|
||||
};
|
||||
|
||||
class ItemProtector
|
||||
{
|
||||
public:
|
||||
static void hold(Item &item)
|
||||
{
|
||||
++item.ref_;
|
||||
}
|
||||
static void release(Item &item)
|
||||
{
|
||||
--item.ref_;
|
||||
}
|
||||
};
|
||||
|
||||
typedef common::hash::ObPreAllocLinkHashMap<int64_t, Item, Node, ItemProtector> TestMap;
|
||||
struct TestForeachFinder: public TestMap::ForeachFunctor
|
||||
{
|
||||
TestForeachFinder(): count_(0) {}
|
||||
virtual ~TestForeachFinder() {}
|
||||
virtual int operator()(Item &item, bool &is_full)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (count_ >= MAX_COUNT) {
|
||||
is_full = true;
|
||||
} else if (item.value_ == 0) {
|
||||
items_[count_++] = &item;
|
||||
} else if (item.value_ == 2) {
|
||||
ret = OB_ERR_SYS;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const int64_t MAX_COUNT = 3;
|
||||
Item *items_[MAX_COUNT];
|
||||
int64_t count_;
|
||||
};
|
||||
|
||||
struct TestForeachCheckRef: public TestMap::ForeachFunctor
|
||||
{
|
||||
TestForeachCheckRef(): count_(0) {}
|
||||
virtual ~TestForeachCheckRef() {}
|
||||
virtual int operator()(Item &item, bool &is_full)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
is_full = false;
|
||||
++count_;
|
||||
if (item.ref_ != 0) {
|
||||
COMMON_LOG(ERROR, "ref not zero", K(item.ref_), K(item.key_));
|
||||
ret = OB_ERR_SYS;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int64_t count_;
|
||||
};
|
||||
|
||||
class TestEraseChecker: public TestMap::EraseChecker
|
||||
|
||||
{
|
||||
public:
|
||||
virtual ~TestEraseChecker() {}
|
||||
virtual int operator()(Item &item)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (item.value_ != 0) {
|
||||
ret = OB_EAGAIN;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
class TestGetFunctor: public TestMap::GetFunctor
|
||||
{
|
||||
public:
|
||||
TestGetFunctor(): item_(NULL) {}
|
||||
virtual ~TestGetFunctor() {}
|
||||
virtual int operator()(Item &item) override
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
item_ = NULL;
|
||||
if (item.value_ == 3) {
|
||||
ret = OB_ERR_SYS;
|
||||
} else {
|
||||
item_ = &item;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
Item *item_;
|
||||
private:
|
||||
DISALLOW_COPY_AND_ASSIGN(TestGetFunctor);
|
||||
};
|
||||
|
||||
TEST(TestObMemLessLinkHashMap, basic)
|
||||
{
|
||||
TestMap map;
|
||||
int64_t buckets_count = 0;
|
||||
uint32_t latch_id = 1;
|
||||
const lib::ObLabel &label = "1";
|
||||
Item item1 = {1,0,0};
|
||||
Node *node1 = map.alloc_node(item1);
|
||||
COMMON_LOG(INFO, "dump", K(item1), K(node1->item_), KP(&item1), KP(&node1->item_));
|
||||
TestForeachFinder finder;
|
||||
|
||||
ASSERT_EQ(OB_NOT_INIT, map.put(*node1));
|
||||
ASSERT_EQ(OB_INVALID_ARGUMENT, map.init(buckets_count, latch_id, label));
|
||||
ASSERT_EQ(OB_INVALID_ARGUMENT, map.init(buckets_count, latch_id, label));
|
||||
buckets_count = 100;
|
||||
ASSERT_EQ(OB_SUCCESS, map.init(buckets_count, latch_id, label));
|
||||
ASSERT_EQ(OB_INIT_TWICE, map.init(buckets_count, latch_id, label));
|
||||
ASSERT_EQ(0, map.get_count());
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node1));
|
||||
ASSERT_EQ(OB_HASH_EXIST, map.put(*node1));
|
||||
ASSERT_EQ(1, map.get_count());
|
||||
|
||||
Item item2 = {1,0,0};
|
||||
Node node2(item2);
|
||||
ASSERT_EQ(OB_HASH_EXIST, map.put(node2));
|
||||
ASSERT_EQ(1, map.get_count());
|
||||
|
||||
Item *get_item = NULL;
|
||||
ASSERT_EQ(OB_SUCCESS, map.get(1, get_item));
|
||||
ASSERT_EQ(&item1, get_item);
|
||||
ASSERT_EQ(OB_SUCCESS, map.foreach(finder));
|
||||
ASSERT_EQ(1, finder.count_);
|
||||
COMMON_LOG(INFO, "dump", K(node1), K(finder.items_[0]));
|
||||
ASSERT_EQ(&item1, finder.items_[0]);
|
||||
|
||||
Item *del_item = NULL;
|
||||
ASSERT_EQ(OB_SUCCESS, map.erase(1, del_item));
|
||||
ASSERT_EQ(&item1, del_item);
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, map.erase(1, del_item));
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, map.get(1, del_item));
|
||||
}
|
||||
|
||||
TEST(TestObMemLessLinkHashMap, same_hash)
|
||||
{
|
||||
TestMap map;
|
||||
int64_t buckets_count = 1;
|
||||
uint32_t latch_id = 1;
|
||||
const lib::ObLabel &label = "1";
|
||||
Item item1 = {1,0,0};
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, map.init(buckets_count, latch_id, label));
|
||||
buckets_count = map.get_buckets_count();
|
||||
Node *node1 = map.alloc_node(item1);
|
||||
Item item2 = {1 + buckets_count,0,0};
|
||||
Node *node2 = map.alloc_node(item2);
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node1));
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node2));
|
||||
ASSERT_EQ(2, map.get_count());
|
||||
|
||||
Item *got_item = NULL;
|
||||
ASSERT_EQ(OB_SUCCESS, map.get(1, got_item));
|
||||
ASSERT_EQ(&item1, got_item);
|
||||
ASSERT_EQ(OB_SUCCESS, map.get(item2.key_, got_item));
|
||||
ASSERT_EQ(&item2, got_item);
|
||||
|
||||
Item *del_item = NULL;
|
||||
ASSERT_EQ(OB_SUCCESS, map.erase(item2.key_, del_item));
|
||||
ASSERT_EQ(&item2, del_item);
|
||||
ASSERT_EQ(OB_SUCCESS, map.erase(item1.key_, del_item));
|
||||
ASSERT_EQ(&item1, del_item);
|
||||
}
|
||||
|
||||
TEST(TestObMemLessLinkHashMap, erase)
|
||||
{
|
||||
TestMap map;
|
||||
int64_t buckets_count = 100;
|
||||
uint32_t latch_id = 1;
|
||||
const lib::ObLabel &label = "1";
|
||||
TestEraseChecker checker;
|
||||
Item *del_item = NULL;
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, map.init(buckets_count, latch_id, label));
|
||||
Item item1 = {1,0,0};
|
||||
Node *node1 = map.alloc_node(item1);
|
||||
Item item2 = {2,1, 0};
|
||||
Node *node2 = map.alloc_node(item2);
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node1));
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node2));
|
||||
ASSERT_EQ(OB_SUCCESS, map.erase(1, del_item, &checker));
|
||||
ASSERT_EQ(del_item, &item1);
|
||||
ASSERT_EQ(OB_EAGAIN, map.erase(2, del_item, &checker));
|
||||
}
|
||||
|
||||
TEST(TestObMemLessLinkHashMap, get_functor)
|
||||
{
|
||||
TestMap map;
|
||||
int64_t buckets_count = 100;
|
||||
uint32_t latch_id = 1;
|
||||
const lib::ObLabel &label = "1";
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, map.init(buckets_count, latch_id, label));
|
||||
|
||||
Item item1 = {1,0,0};
|
||||
Node *node1 = map.alloc_node(item1);
|
||||
Item item2 = {2,3, 0};
|
||||
Node *node2 = map.alloc_node(item2);
|
||||
TestGetFunctor get_functor;
|
||||
Item *got_item = NULL;
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node1));
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node2));
|
||||
ASSERT_EQ(OB_SUCCESS, map.get(1, got_item, &get_functor));
|
||||
ASSERT_EQ(got_item, &item1);
|
||||
ASSERT_EQ(OB_SUCCESS, map.get(1, get_functor));
|
||||
ASSERT_EQ(get_functor.item_, &item1);
|
||||
ASSERT_EQ(OB_ERR_SYS, map.get(2, got_item, &get_functor));
|
||||
ASSERT_TRUE(got_item == NULL);
|
||||
ASSERT_TRUE(get_functor.item_ == NULL);
|
||||
ASSERT_EQ(OB_HASH_EXIST, map.exist(1));
|
||||
ASSERT_EQ(OB_HASH_EXIST, map.exist(2));
|
||||
ASSERT_EQ(OB_HASH_NOT_EXIST, map.exist(3));
|
||||
}
|
||||
|
||||
|
||||
TEST(TestObMemLessLinkHashMap, foreach)
|
||||
{
|
||||
TestMap map;
|
||||
int64_t buckets_count = 100;
|
||||
uint32_t latch_id = 1;
|
||||
const lib::ObLabel &label = "1";
|
||||
const int64_t count = 10000;
|
||||
Item *items[count];
|
||||
TestForeachFinder finder;
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, map.init(buckets_count, latch_id, label));
|
||||
|
||||
for (int64_t i = 0; i < count; ++i) {
|
||||
Item *item = new Item();
|
||||
item->key_ = i;
|
||||
item->value_ = i % 2;
|
||||
Node *node = map.alloc_node(*item);
|
||||
items[i] = item;
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node));
|
||||
}
|
||||
|
||||
for (int64_t i = 0; i < count; ++i) {
|
||||
Item *got_item = NULL;
|
||||
ASSERT_EQ(OB_SUCCESS, map.get(i, got_item));
|
||||
ASSERT_EQ(items[i], got_item);
|
||||
}
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, map.foreach(finder));
|
||||
ASSERT_EQ(3, finder.count_);
|
||||
for (int64_t i = 0; i < 3; ++i) {
|
||||
COMMON_LOG(INFO, "dump", K(items[2 * i]), K(*finder.items_[i]));
|
||||
}
|
||||
|
||||
|
||||
for (int64_t i = 0; i < count; ++i) {
|
||||
delete items[i];
|
||||
}
|
||||
}
|
||||
|
||||
TEST(TestObMemLessLinkHashMap, iterator)
|
||||
{
|
||||
TestMap map;
|
||||
TestMap::Iterator iter(map);
|
||||
int64_t buckets_count = 100000;
|
||||
uint32_t latch_id = 1;
|
||||
const lib::ObLabel &label = "1";
|
||||
ASSERT_EQ(OB_SUCCESS, map.init(buckets_count, latch_id, label));
|
||||
Item item1 = {1,0,0};
|
||||
Node *node1 = map.alloc_node(item1);
|
||||
Item item2 = {2,3, 0};
|
||||
Node *node2 = map.alloc_node(item2);
|
||||
TestGetFunctor get_functor;
|
||||
Item *got_item = NULL;
|
||||
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node1));
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node2));
|
||||
ASSERT_EQ(OB_SUCCESS, iter.get_next(got_item));
|
||||
ASSERT_EQ(&item1, got_item);
|
||||
ASSERT_EQ(OB_SUCCESS, iter.get_next(got_item));
|
||||
ASSERT_EQ(&item2, got_item);
|
||||
ASSERT_EQ(OB_ITER_END, iter.get_next(got_item));
|
||||
}
|
||||
|
||||
TEST(TestObMemLessLinkHashMap, iterator2)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
TestMap map;
|
||||
int64_t buckets_count = 100;
|
||||
uint32_t latch_id = 1;
|
||||
const lib::ObLabel &label = "1";
|
||||
ASSERT_EQ(OB_SUCCESS, map.init(buckets_count, latch_id, label));
|
||||
|
||||
const int64_t count = 8061;
|
||||
for (int64_t i = 0; i < count; ++i) {
|
||||
Item *item = new Item();
|
||||
item->key_ = i;
|
||||
item->value_ = i;
|
||||
item->ref_ = 0;
|
||||
Node *node = map.alloc_node(*item);
|
||||
ASSERT_EQ(OB_SUCCESS, map.put(*node));
|
||||
}
|
||||
|
||||
{
|
||||
TestMap::Iterator iter(map);
|
||||
Item *got_item = NULL;
|
||||
int64_t num = 0;
|
||||
while (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(iter.get_next(got_item))) {
|
||||
COMMON_LOG(WARN, "rend", K(ret), K(num));
|
||||
} else {
|
||||
++num;
|
||||
}
|
||||
}
|
||||
ASSERT_EQ(OB_ITER_END, ret);
|
||||
}
|
||||
|
||||
TestForeachCheckRef checker;
|
||||
ASSERT_EQ(OB_SUCCESS, map.foreach(checker));
|
||||
ASSERT_EQ(count, checker.count_);
|
||||
|
||||
}
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
OB_LOGGER.set_log_level("INFO");
|
||||
testing::InitGoogleTest(&argc,argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
@ -17,7 +17,6 @@
|
||||
|
||||
#include "share/ob_define.h" // OB_*
|
||||
#include "lib/allocator/ob_allocator.h" // ObIAllocator
|
||||
#include "lib/hash/ob_ext_iter_hashset.h" // ObExtIterHashSet
|
||||
#include "lib/container/ob_se_array.h" // ObSEArray
|
||||
#include "lib/allocator/page_arena.h" // ObArenaAllocator
|
||||
#include "lib/lock/ob_spin_lock.h" // ObSpinLock
|
||||
|
||||
@ -234,9 +234,7 @@ int ObRemoteFetchLogImpl::get_palf_base_lsn_scn_(ObLS &ls, LSN &lsn, SCN &scn)
|
||||
} else if (OB_FAIL(palf_handle_guard.get_end_lsn(lsn))) {
|
||||
LOG_WARN("get end lsn failed", K(ret), K(id));
|
||||
} else {
|
||||
int64_t checkpoint_ts = ls.get_clog_checkpoint_ts();
|
||||
SCN checkpoint_scn;
|
||||
checkpoint_scn.convert_tmp(checkpoint_ts);
|
||||
const SCN &checkpoint_scn = ls.get_clog_checkpoint_scn();
|
||||
scn = SCN::max(scn, checkpoint_scn);
|
||||
}
|
||||
return ret;
|
||||
|
||||
@ -2182,7 +2182,6 @@ int ObRootService::renew_lease(const ObLeaseRequest &lease_request,
|
||||
// before __all_zone load, it may fail, ignore it
|
||||
int temp_ret = OB_SUCCESS;
|
||||
int64_t lease_info_version = 0;
|
||||
int64_t frozen_timestamp = 0;
|
||||
bool is_stopped = false;
|
||||
int64_t leader_cnt = -1;
|
||||
bool has_leader = true;
|
||||
|
||||
@ -40,7 +40,7 @@ public:
|
||||
share::ObLSTableOperator &lst_operator,
|
||||
ObMySQLTransaction &trans)
|
||||
: tenant_id_(tenant_id),
|
||||
tablet_creator_(tenant_id, frozen_scn.get_val_for_lsn_allocator(), lst_operator, trans),
|
||||
tablet_creator_(tenant_id, frozen_scn, lst_operator, trans),
|
||||
trans_(trans),
|
||||
ls_id_array_(),
|
||||
inited_(false) {}
|
||||
|
||||
@ -108,7 +108,7 @@ DEF_TO_STRING(ObTabletCreatorArg)
|
||||
/////////////////////////////////////////////////////////
|
||||
|
||||
int ObBatchCreateTabletHelper::init(const share::ObLSID &ls_key, const int64_t tenant_id,
|
||||
const int64_t frozen_timestamp)
|
||||
const palf::SCN &major_frozen_scn)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
const int64_t bucket_count = hash::cal_next_prime(100);
|
||||
@ -117,8 +117,8 @@ int ObBatchCreateTabletHelper::init(const share::ObLSID &ls_key, const int64_t t
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("invalid argument", KR(ret), K(tenant_id), K(ls_key));
|
||||
} else if (OB_FAIL(arg_.init_create_tablet(ls_key,
|
||||
frozen_timestamp))) {
|
||||
LOG_WARN("failed to init create tablet", KR(ret), K(tenant_id), K(ls_key), K(frozen_timestamp));
|
||||
major_frozen_scn))) {
|
||||
LOG_WARN("failed to init create tablet", KR(ret), K(tenant_id), K(ls_key), K(major_frozen_scn));
|
||||
} else if (OB_FAIL(table_schemas_map_.create(bucket_count, "CreateTablet", "CreateTablet"))) {
|
||||
LOG_WARN("failed to create hashmap", KR(ret));
|
||||
}
|
||||
@ -252,7 +252,7 @@ int ObTabletCreator::add_create_tablet_arg(const ObTabletCreatorArg &arg)
|
||||
ret = OB_ALLOCATE_MEMORY_FAILED;
|
||||
LOG_WARN("failed to allocate new arg", KR(ret), KP(batch_arg));
|
||||
} else if (FALSE_IT(batch_arg = new (arg_buf)ObBatchCreateTabletHelper())) {
|
||||
} else if (OB_FAIL(batch_arg->init(arg.ls_key_, tenant_id_, frozen_timestamp_))) {
|
||||
} else if (OB_FAIL(batch_arg->init(arg.ls_key_, tenant_id_, major_frozen_scn_))) {
|
||||
LOG_WARN("failed to init batch arg helper", KR(ret), K(arg));
|
||||
} else if (OB_FAIL(args_map_.set_refactored(arg.ls_key_, batch_arg, 0/*not overwrite*/))) {
|
||||
LOG_WARN("fail to set refactored", KR(ret), K(arg));
|
||||
@ -271,7 +271,7 @@ int ObTabletCreator::add_create_tablet_arg(const ObTabletCreatorArg &arg)
|
||||
ret = OB_ALLOCATE_MEMORY_FAILED;
|
||||
LOG_WARN("failed to allocate new arg", KR(ret));
|
||||
} else if (FALSE_IT(new_arg = new (arg_buf)ObBatchCreateTabletHelper())) {
|
||||
} else if (OB_FAIL(new_arg->init(arg.ls_key_, tenant_id_, frozen_timestamp_))) {
|
||||
} else if (OB_FAIL(new_arg->init(arg.ls_key_, tenant_id_, major_frozen_scn_))) {
|
||||
LOG_WARN("failed to init batch arg helper", KR(ret), K(arg));
|
||||
} else if (FALSE_IT(new_arg->next_ = batch_arg)) {
|
||||
} else if (OB_FAIL(args_map_.set_refactored(arg.ls_key_, new_arg, 1/*not overwrite*/))) {
|
||||
|
||||
@ -72,7 +72,7 @@ public:
|
||||
ObBatchCreateTabletHelper() :arg_(), table_schemas_map_(), result_(common::OB_NOT_MASTER), next_(NULL) {}
|
||||
int init(const share::ObLSID &ls_key,
|
||||
const int64_t tenant_id,
|
||||
const int64_t frozen_timestamp);
|
||||
const palf::SCN &major_frozen_scn);
|
||||
int try_add_table_schema(const share::schema::ObTableSchema *table_schema, int64_t &index);
|
||||
int add_arg_to_batch_arg(const ObTabletCreatorArg &arg);
|
||||
void reset()
|
||||
@ -97,11 +97,11 @@ class ObTabletCreator
|
||||
public:
|
||||
ObTabletCreator(
|
||||
const uint64_t tenant_id,
|
||||
int64_t frozen_timestamp,
|
||||
const palf::SCN &major_frozen_scn,
|
||||
share::ObLSTableOperator &lst_operator,
|
||||
ObMySQLTransaction &trans)
|
||||
: tenant_id_(tenant_id),
|
||||
frozen_timestamp_(frozen_timestamp),
|
||||
major_frozen_scn_(major_frozen_scn),
|
||||
lst_operator_(&lst_operator),
|
||||
allocator_("TbtCret"),
|
||||
args_map_(),
|
||||
@ -119,7 +119,7 @@ private:
|
||||
const int64_t MAP_BUCKET_NUM = 1024;
|
||||
private:
|
||||
const uint64_t tenant_id_;
|
||||
const int64_t frozen_timestamp_;
|
||||
const palf::SCN major_frozen_scn_;
|
||||
share::ObLSTableOperator *lst_operator_;
|
||||
ObArenaAllocator allocator_;
|
||||
common::hash::ObHashMap<share::ObLSID, ObBatchCreateTabletHelper*> args_map_;
|
||||
|
||||
@ -609,7 +609,7 @@ int ObInnerTableSchema::cdb_ob_archivelog_piece_files_schema(ObTableSchema &tabl
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, DEST_ID, ROUND_ID, PIECE_ID, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, MAX_SCN, END_SCN, COMPATIBLE, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, FILE_STATUS, PATH FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PIECE_FILES )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, DEST_ID, ROUND_ID, PIECE_ID, INCARNATION, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, MAX_SCN, END_SCN, COMPATIBLE, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, FILE_STATUS, PATH FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PIECE_FILES )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -659,7 +659,7 @@ int ObInnerTableSchema::cdb_ob_backup_set_files_schema(ObTableSchema &table_sche
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, BACKUP_SET_ID, DEST_ID, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, CASE WHEN START_REPLAY_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_REPLAY_SCN) END AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, CASE WHEN MIN_RESTORE_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) END AS MIN_RESTORE_SCN_DISPLAY, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_SET_FILES )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, BACKUP_SET_ID, DEST_ID, INCARNATION, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, CASE WHEN START_REPLAY_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_REPLAY_SCN) END AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, CASE WHEN MIN_RESTORE_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) END AS MIN_RESTORE_SCN_DISPLAY, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_SET_FILES )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
|
||||
@ -159,7 +159,7 @@ int ObInnerTableSchema::cdb_ob_backup_jobs_schema(ObTableSchema &table_schema)
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, JOB_ID, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, RESULT, COMMENT, DESCRIPTION, PATH FROM OCEANBASE.__all_virtual_backup_job )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, JOB_ID, INCARNATION, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, RESULT, COMMENT, DESCRIPTION, PATH FROM OCEANBASE.__all_virtual_backup_job )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -209,7 +209,7 @@ int ObInnerTableSchema::cdb_ob_backup_job_history_schema(ObTableSchema &table_sc
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, JOB_ID, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, RESULT, COMMENT, DESCRIPTION, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_JOB_HISTORY )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, JOB_ID, INCARNATION, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, RESULT, COMMENT, DESCRIPTION, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_JOB_HISTORY )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -259,7 +259,7 @@ int ObInnerTableSchema::cdb_ob_backup_tasks_schema(ObTableSchema &table_schema)
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, TASK_ID, JOB_ID, BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, PATH FROM OCEANBASE.__all_virtual_backup_task )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, TASK_ID, JOB_ID, INCARNATION, BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, PATH FROM OCEANBASE.__all_virtual_backup_task )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -309,7 +309,7 @@ int ObInnerTableSchema::cdb_ob_backup_task_history_schema(ObTableSchema &table_s
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, TASK_ID, JOB_ID, BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_TASK_HISTORY )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, TASK_ID, JOB_ID, INCARNATION, BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_TASK_HISTORY )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
|
||||
@ -2159,7 +2159,7 @@ int ObInnerTableSchema::cdb_ob_backup_delete_jobs_schema(ObTableSchema &table_sc
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, JOB_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, USEC_TO_TIME(PARAMETER) AS PARAMETER, JOB_LEVEL, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, COMMENT FROM oceanbase.__all_virtual_backup_delete_job )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, JOB_ID, INCARNATION, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, USEC_TO_TIME(PARAMETER) AS PARAMETER, JOB_LEVEL, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, COMMENT FROM oceanbase.__all_virtual_backup_delete_job )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2209,7 +2209,7 @@ int ObInnerTableSchema::cdb_ob_backup_delete_job_history_schema(ObTableSchema &t
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, JOB_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, USEC_TO_TIME(PARAMETER) AS PARAMETER, JOB_LEVEL, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, COMMENT FROM oceanbase.__all_virtual_backup_delete_job_history )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, JOB_ID, INCARNATION, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, USEC_TO_TIME(PARAMETER) AS PARAMETER, JOB_LEVEL, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, COMMENT FROM oceanbase.__all_virtual_backup_delete_job_history )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2259,7 +2259,7 @@ int ObInnerTableSchema::cdb_ob_backup_delete_tasks_schema(ObTableSchema &table_s
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, TASK_ID, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, COMMENT, PATH FROM oceanbase.__all_virtual_backup_delete_task )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, TASK_ID, INCARNATION, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, COMMENT, PATH FROM oceanbase.__all_virtual_backup_delete_task )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2309,7 +2309,7 @@ int ObInnerTableSchema::cdb_ob_backup_delete_task_history_schema(ObTableSchema &
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, TASK_ID, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, COMMENT, PATH FROM oceanbase.__all_virtual_backup_delete_task_history )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, TASK_ID, INCARNATION, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, COMMENT, PATH FROM oceanbase.__all_virtual_backup_delete_task_history )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
|
||||
@ -559,7 +559,7 @@ int ObInnerTableSchema::dba_ob_backup_jobs_schema(ObTableSchema &table_schema)
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, RESULT, COMMENT, DESCRIPTION, PATH FROM OCEANBASE.__all_virtual_backup_job WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INCARNATION, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, RESULT, COMMENT, DESCRIPTION, PATH FROM OCEANBASE.__all_virtual_backup_job WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -609,7 +609,7 @@ int ObInnerTableSchema::dba_ob_backup_job_history_schema(ObTableSchema &table_sc
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, RESULT, COMMENT, DESCRIPTION, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_JOB_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INCARNATION, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, RESULT, COMMENT, DESCRIPTION, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_JOB_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -659,7 +659,7 @@ int ObInnerTableSchema::dba_ob_backup_tasks_schema(ObTableSchema &table_schema)
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, PATH FROM OCEANBASE.__all_virtual_backup_task WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, INCARNATION, BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, PATH FROM OCEANBASE.__all_virtual_backup_task WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -709,7 +709,7 @@ int ObInnerTableSchema::dba_ob_backup_task_history_schema(ObTableSchema &table_s
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_TASK_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, INCARNATION, BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_TASK_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -759,7 +759,7 @@ int ObInnerTableSchema::dba_ob_backup_set_files_schema(ObTableSchema &table_sche
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT BACKUP_SET_ID, DEST_ID, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, CASE WHEN START_REPLAY_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_REPLAY_SCN) END AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, CASE WHEN MIN_RESTORE_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) END AS MIN_RESTORE_SCN_DISPLAY, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_SET_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT BACKUP_SET_ID, DEST_ID, INCARNATION, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_BACKUP_SET_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, CASE WHEN START_REPLAY_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_REPLAY_SCN) END AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, CASE WHEN MIN_RESTORE_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) END AS MIN_RESTORE_SCN_DISPLAY, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, COMMENT, ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_SET_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1459,7 +1459,7 @@ int ObInnerTableSchema::dba_ob_backup_delete_jobs_schema(ObTableSchema &table_sc
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, USEC_TO_TIME(PARAMETER) AS PARAMETER, JOB_LEVEL, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_DELETE_JOB WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INCARNATION, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, USEC_TO_TIME(PARAMETER) AS PARAMETER, JOB_LEVEL, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_DELETE_JOB WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1509,7 +1509,7 @@ int ObInnerTableSchema::dba_ob_backup_delete_job_history_schema(ObTableSchema &t
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, USEC_TO_TIME(PARAMETER) AS PARAMETER, JOB_LEVEL, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_DELETE_JOB_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INCARNATION, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, USEC_TO_TIME(PARAMETER) AS PARAMETER, JOB_LEVEL, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_DELETE_JOB_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1559,7 +1559,7 @@ int ObInnerTableSchema::dba_ob_backup_delete_tasks_schema(ObTableSchema &table_s
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_DELETE_TASK WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, INCARNATION, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_DELETE_TASK WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1609,7 +1609,7 @@ int ObInnerTableSchema::dba_ob_backup_delete_task_history_schema(ObTableSchema &
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_DELETE_TASK_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, INCARNATION, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, USEC_TO_TIME(START_TS) AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE USEC_TO_TIME(END_TS) END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_BACKUP_DELETE_TASK_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1909,7 +1909,7 @@ int ObInnerTableSchema::dba_ob_archivelog_schema(ObTableSchema &table_schema)
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, CASE WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) = 0 THEN 0 ELSE ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) / (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES), 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, INCARNATION, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, CASE WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) = 0 THEN 0 ELSE ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) / (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES), 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1959,7 +1959,7 @@ int ObInnerTableSchema::dba_ob_archivelog_summary_schema(ObTableSchema &table_sc
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, PATH, COMMENT FROM ( SELECT DEST_ID, ROUND_ID, DEST_NO, STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS WHERE TENANT_ID = EFFECTIVE_TENANT_ID() AND STATUS != 'STOP' UNION SELECT DEST_ID, ROUND_ID, DEST_NO, 'STOP' AS STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID()) )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, INCARNATION, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, PATH, COMMENT FROM ( SELECT DEST_ID, ROUND_ID, INCARNATION, DEST_NO, STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS WHERE TENANT_ID = EFFECTIVE_TENANT_ID() AND STATUS != 'STOP' UNION SELECT DEST_ID, ROUND_ID, INCARNATION, DEST_NO, 'STOP' AS STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID()) )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2009,7 +2009,7 @@ int ObInnerTableSchema::dba_ob_archivelog_piece_files_schema(ObTableSchema &tabl
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, PIECE_ID, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, MAX_SCN, END_SCN, COMPATIBLE, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, FILE_STATUS, PATH FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PIECE_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, PIECE_ID, INCARNATION, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, MAX_SCN, END_SCN, COMPATIBLE, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, FILE_STATUS, PATH FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PIECE_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2159,7 +2159,7 @@ int ObInnerTableSchema::cdb_ob_archivelog_schema(ObTableSchema &table_schema)
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, DEST_ID, ROUND_ID, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, CASE WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) = 0 THEN 0 ELSE ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) / (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES), 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, DEST_ID, ROUND_ID, INCARNATION, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, CASE WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) = 0 THEN 0 ELSE ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) / (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES), 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, COMMENT, PATH FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2209,7 +2209,7 @@ int ObInnerTableSchema::cdb_ob_archivelog_summary_schema(ObTableSchema &table_sc
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, DEST_ID, ROUND_ID, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, PATH, COMMENT FROM ( SELECT TENANT_ID, DEST_ID, ROUND_ID, DEST_NO, STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS WHERE STATUS != 'STOP' UNION SELECT TENANT_ID, DEST_ID, ROUND_ID, DEST_NO, 'STOP' AS STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_HISTORY) )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TENANT_ID, DEST_ID, ROUND_ID, INCARNATION, DEST_NO, STATUS, START_SCN, CASE WHEN START_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(START_SCN) END AS START_SCN_DISPLAY, CHECKPOINT_SCN, CASE WHEN CHECKPOINT_SCN = 0 THEN '' ELSE SCN_TO_TIMESTAMP(CHECKPOINT_SCN) END AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, PATH, COMMENT FROM ( SELECT TENANT_ID, DEST_ID, ROUND_ID, INCARNATION, DEST_NO, STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS WHERE STATUS != 'STOP' UNION SELECT TENANT_ID, DEST_ID, ROUND_ID, INCARNATION, DEST_NO, 'STOP' AS STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, COMMENT FROM OCEANBASE.__ALL_VIRTUAL_LOG_ARCHIVE_HISTORY) )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1359,7 +1359,7 @@ int ObInnerTableSchema::dba_ob_backup_jobs_ora_schema(ObTableSchema &table_schem
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, RESULT, "COMMENT", DESCRIPTION, PATH FROM SYS.ALL_VIRTUAL_BACKUP_JOB WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INCARNATION, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, RESULT, "COMMENT", DESCRIPTION, PATH FROM SYS.ALL_VIRTUAL_BACKUP_JOB WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1409,7 +1409,7 @@ int ObInnerTableSchema::dba_ob_backup_job_history_ora_schema(ObTableSchema &tabl
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, RESULT, "COMMENT", DESCRIPTION, PATH FROM SYS.ALL_VIRTUAL_BACKUP_JOB_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INCARNATION, BACKUP_SET_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, PLUS_ARCHIVELOG, BACKUP_TYPE, JOB_LEVEL, ENCRYPTION_MODE, PASSWD, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, RESULT, "COMMENT", DESCRIPTION, PATH FROM SYS.ALL_VIRTUAL_BACKUP_JOB_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1459,7 +1459,7 @@ int ObInnerTableSchema::dba_ob_backup_tasks_ora_schema(ObTableSchema &table_sche
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, BACKUP_SET_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, "COMMENT", PATH FROM SYS.ALL_VIRTUAL_BACKUP_TASK WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, INCARNATION, BACKUP_SET_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, "COMMENT", PATH FROM SYS.ALL_VIRTUAL_BACKUP_TASK WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1509,7 +1509,7 @@ int ObInnerTableSchema::dba_ob_backup_task_history_ora_schema(ObTableSchema &tab
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, BACKUP_SET_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, "COMMENT", PATH FROM SYS.ALL_VIRTUAL_BACKUP_TASK_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, INCARNATION, BACKUP_SET_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, START_SCN, END_SCN, USER_LS_START_SCN, ENCRYPTION_MODE, PASSWD, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, "COMMENT", PATH FROM SYS.ALL_VIRTUAL_BACKUP_TASK_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1559,7 +1559,7 @@ int ObInnerTableSchema::dba_ob_backup_set_files_ora_schema(ObTableSchema &table_
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT BACKUP_SET_ID, DEST_ID, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_BACKUP_SET_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, SCN_TO_TIMESTAMP(START_REPLAY_SCN) AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) AS MIN_RESTORE_SCN_DISPLAY, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, "COMMENT", ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH FROM SYS.ALL_VIRTUAL_BACKUP_SET_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT BACKUP_SET_ID, DEST_ID, INCARNATION, BACKUP_TYPE, PREV_FULL_BACKUP_SET_ID, PREV_INC_BACKUP_SET_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, FILE_STATUS, CASE WHEN END_TS = 0 THEN 0 ELSE ROUND((END_TS - START_TS)/1000/1000,0) END AS ELAPSED_SECONDES, PLUS_ARCHIVELOG, START_REPLAY_SCN, SCN_TO_TIMESTAMP(START_REPLAY_SCN) AS START_REPLAY_SCN_DISPLAY, MIN_RESTORE_SCN, SCN_TO_TIMESTAMP(MIN_RESTORE_SCN) AS MIN_RESTORE_SCN_DISPLAY, INPUT_BYTES, OUTPUT_BYTES, CASE WHEN END_TS = 0 THEN 0 ELSE OUTPUT_BYTES / ((END_TS - START_TS)/1000/1000) END AS OUTPUT_RATE_BYTES, EXTRA_BYTES AS EXTRA_META_BYTES, TABLET_COUNT, FINISH_TABLET_COUNT, MACRO_BLOCK_COUNT, FINISH_MACRO_BLOCK_COUNT, FILE_COUNT, META_TURN_ID, DATA_TURN_ID, RESULT, "COMMENT", ENCRYPTION_MODE, PASSWD, TENANT_COMPATIBLE, BACKUP_COMPATIBLE, PATH FROM SYS.ALL_VIRTUAL_BACKUP_SET_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1909,7 +1909,7 @@ int ObInnerTableSchema::dba_ob_backup_delete_jobs_ora_schema(ObTableSchema &tabl
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, TO_CHAR(PARAMETER / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS PARAMETER, JOB_LEVEL, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, "COMMENT" FROM SYS.ALL_VIRTUAL_BACKUP_DELETE_JOB WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INCARNATION, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, TO_CHAR(PARAMETER / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS PARAMETER, JOB_LEVEL, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, "COMMENT" FROM SYS.ALL_VIRTUAL_BACKUP_DELETE_JOB WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -1959,7 +1959,7 @@ int ObInnerTableSchema::dba_ob_backup_delete_job_history_ora_schema(ObTableSchem
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, TO_CHAR(PARAMETER / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS PARAMETER, JOB_LEVEL, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, "COMMENT" FROM SYS.ALL_VIRTUAL_BACKUP_DELETE_JOB_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT JOB_ID, INCARNATION, INITIATOR_TENANT_ID, INITIATOR_JOB_ID, EXECUTOR_TENANT_ID, TYPE, TO_CHAR(PARAMETER / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS PARAMETER, JOB_LEVEL, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, TASK_COUNT, SUCCESS_TASK_COUNT, RESULT, "COMMENT" FROM SYS.ALL_VIRTUAL_BACKUP_DELETE_JOB_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2009,7 +2009,7 @@ int ObInnerTableSchema::dba_ob_backup_delete_tasks_ora_schema(ObTableSchema &tab
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, "COMMENT", PATH FROM SYS.ALL_VIRTUAL_BACKUP_DELETE_TASK WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, INCARNATION, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, "COMMENT", PATH FROM SYS.ALL_VIRTUAL_BACKUP_DELETE_TASK WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2059,7 +2059,7 @@ int ObInnerTableSchema::dba_ob_backup_delete_task_history_ora_schema(ObTableSche
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, "COMMENT", PATH FROM SYS.ALL_VIRTUAL_BACKUP_DELETE_TASK_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT TASK_ID, INCARNATION, JOB_ID, TASK_TYPE, ID, ROUND_ID, DEST_ID, TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP, CASE WHEN END_TS = 0 THEN '' ELSE TO_CHAR(END_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') END AS END_TIMESTAMP, STATUS, TOTAL_LS_COUNT, FINISH_LS_COUNT, RESULT, "COMMENT", PATH FROM SYS.ALL_VIRTUAL_BACKUP_DELETE_TASK_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2259,7 +2259,7 @@ int ObInnerTableSchema::dba_ob_archivelog_ora_schema(ObTableSchema &table_schema
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, DEST_NO, STATUS, START_SCN, SCN_TO_TIMESTAMP(START_SCN) AS START_SCN_DISPLAY, CHECKPOINT_SCN, SCN_TO_TIMESTAMP(CHECKPOINT_SCN) AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, CASE WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) = 0 THEN 0 ELSE ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) / (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES), 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, "COMMENT", PATH FROM SYS.ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, INCARNATION, DEST_NO, STATUS, START_SCN, SCN_TO_TIMESTAMP(START_SCN) AS START_SCN_DISPLAY, CHECKPOINT_SCN, SCN_TO_TIMESTAMP(CHECKPOINT_SCN) AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES)/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, CASE WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024/1024,2), 'PB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024/1024,2), 'TB') WHEN (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) >= 1024*1024*1024 THEN CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES)/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) = 0 THEN 0 ELSE ROUND((FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) / (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES), 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, "COMMENT", PATH FROM SYS.ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2309,7 +2309,7 @@ int ObInnerTableSchema::dba_ob_archivelog_summary_ora_schema(ObTableSchema &tabl
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, DEST_NO, STATUS, START_SCN, SCN_TO_TIMESTAMP(START_SCN) AS START_SCN_DISPLAY, CHECKPOINT_SCN, SCN_TO_TIMESTAMP(CHECKPOINT_SCN) AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, PATH, "COMMENT" FROM ( SELECT DEST_ID, ROUND_ID, DEST_NO, STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, "COMMENT" FROM SYS.ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS WHERE TENANT_ID = EFFECTIVE_TENANT_ID() AND STATUS != 'STOP' UNION SELECT DEST_ID, ROUND_ID, DEST_NO, 'STOP' AS STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, "COMMENT" FROM SYS.ALL_VIRTUAL_LOG_ARCHIVE_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID()) )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, INCARNATION, DEST_NO, STATUS, START_SCN, SCN_TO_TIMESTAMP(START_SCN) AS START_SCN_DISPLAY, CHECKPOINT_SCN, SCN_TO_TIMESTAMP(CHECKPOINT_SCN) AS CHECKPOINT_SCN_DISPLAY, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, DELETED_INPUT_BYTES, CASE WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_INPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_INPUT_BYTES_DISPLAY, DELETED_OUTPUT_BYTES, CASE WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN DELETED_OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(DELETED_OUTPUT_BYTES/1024/1024,2), 'MB') END AS DELETED_OUTPUT_BYTES_DISPLAY, PATH, "COMMENT" FROM ( SELECT DEST_ID, ROUND_ID, INCARNATION, DEST_NO, STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, (FROZEN_INPUT_BYTES + ACTIVE_INPUT_BYTES) AS INPUT_BYTES, (FROZEN_OUTPUT_BYTES + ACTIVE_OUTPUT_BYTES) AS OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, "COMMENT" FROM SYS.ALL_VIRTUAL_LOG_ARCHIVE_PROGRESS WHERE TENANT_ID = EFFECTIVE_TENANT_ID() AND STATUS != 'STOP' UNION SELECT DEST_ID, ROUND_ID, INCARNATION, DEST_NO, 'STOP' AS STATUS, START_SCN, CHECKPOINT_SCN, COMPATIBLE, BASE_PIECE_ID, USED_PIECE_ID, PIECE_SWITCH_INTERVAL, UNIT_SIZE, COMPRESSION, INPUT_BYTES, OUTPUT_BYTES, DELETED_INPUT_BYTES, DELETED_OUTPUT_BYTES, PATH, "COMMENT" FROM SYS.ALL_VIRTUAL_LOG_ARCHIVE_HISTORY WHERE TENANT_ID = EFFECTIVE_TENANT_ID()) )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
@ -2359,7 +2359,7 @@ int ObInnerTableSchema::dba_ob_archivelog_piece_files_ora_schema(ObTableSchema &
|
||||
table_schema.set_collation_type(ObCharset::get_default_collation(ObCharset::get_default_charset()));
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, PIECE_ID, DEST_NO, STATUS, START_SCN, SCN_TO_TIMESTAMP(START_SCN) AS START_SCN_DISPLAY, CHECKPOINT_SCN, SCN_TO_TIMESTAMP(CHECKPOINT_SCN) AS CHECKPOINT_SCN_DISPLAY, MAX_SCN, END_SCN, COMPATIBLE, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, FILE_STATUS, PATH FROM SYS.ALL_VIRTUAL_LOG_ARCHIVE_PIECE_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
if (OB_FAIL(table_schema.set_view_definition(R"__( SELECT DEST_ID, ROUND_ID, PIECE_ID, INCARNATION, DEST_NO, STATUS, START_SCN, SCN_TO_TIMESTAMP(START_SCN) AS START_SCN_DISPLAY, CHECKPOINT_SCN, SCN_TO_TIMESTAMP(CHECKPOINT_SCN) AS CHECKPOINT_SCN_DISPLAY, MAX_SCN, END_SCN, COMPATIBLE, UNIT_SIZE, COMPRESSION, INPUT_BYTES, CASE WHEN INPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN INPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN INPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(INPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(INPUT_BYTES/1024/1024,2), 'MB') END AS INPUT_BYTES_DISPLAY, OUTPUT_BYTES, CASE WHEN OUTPUT_BYTES >= 1024*1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024/1024,2), 'PB') WHEN OUTPUT_BYTES >= 1024*1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024/1024,2), 'TB') WHEN OUTPUT_BYTES >= 1024*1024*1024 THEN CONCAT(ROUND(OUTPUT_BYTES/1024/1024/1024,2), 'GB') ELSE CONCAT(ROUND(OUTPUT_BYTES/1024/1024,2), 'MB') END AS OUTPUT_BYTES_DISPLAY, CASE WHEN INPUT_BYTES = 0 THEN 0 ELSE ROUND(OUTPUT_BYTES / INPUT_BYTES, 2) END AS COMPRESSION_RATIO, FILE_STATUS, PATH FROM SYS.ALL_VIRTUAL_LOG_ARCHIVE_PIECE_FILES WHERE TENANT_ID = EFFECTIVE_TENANT_ID() )__"))) {
|
||||
LOG_ERROR("fail to set view_definition", K(ret));
|
||||
}
|
||||
}
|
||||
|
||||
@ -13928,6 +13928,7 @@ def_table_schema(
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
PIECE_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -13996,6 +13997,7 @@ def_table_schema(
|
||||
TENANT_ID,
|
||||
BACKUP_SET_ID,
|
||||
DEST_ID,
|
||||
INCARNATION,
|
||||
BACKUP_TYPE,
|
||||
PREV_FULL_BACKUP_SET_ID,
|
||||
PREV_INC_BACKUP_SET_ID,
|
||||
@ -14269,6 +14271,7 @@ def_table_schema(
|
||||
SELECT
|
||||
TENANT_ID,
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
@ -14306,6 +14309,7 @@ def_table_schema(
|
||||
SELECT
|
||||
TENANT_ID,
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
@ -14344,6 +14348,7 @@ def_table_schema(
|
||||
TENANT_ID,
|
||||
TASK_ID,
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
USEC_TO_TIME(START_TS) AS START_TIMESTAMP,
|
||||
CASE
|
||||
@ -14394,6 +14399,7 @@ def_table_schema(
|
||||
TENANT_ID,
|
||||
TASK_ID,
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
USEC_TO_TIME(START_TS) AS START_TIMESTAMP,
|
||||
CASE
|
||||
@ -19591,6 +19597,7 @@ def_table_schema(
|
||||
SELECT
|
||||
TENANT_ID,
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
EXECUTOR_TENANT_ID,
|
||||
@ -19625,6 +19632,7 @@ def_table_schema(
|
||||
SELECT
|
||||
TENANT_ID,
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
EXECUTOR_TENANT_ID,
|
||||
@ -19659,6 +19667,7 @@ def_table_schema(
|
||||
SELECT
|
||||
TENANT_ID,
|
||||
TASK_ID,
|
||||
INCARNATION,
|
||||
JOB_ID,
|
||||
TASK_TYPE,
|
||||
ID,
|
||||
@ -19693,6 +19702,7 @@ def_table_schema(
|
||||
SELECT
|
||||
TENANT_ID,
|
||||
TASK_ID,
|
||||
INCARNATION,
|
||||
JOB_ID,
|
||||
TASK_TYPE,
|
||||
ID,
|
||||
@ -20440,6 +20450,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
@ -20479,6 +20490,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
@ -20519,6 +20531,7 @@ def_table_schema(
|
||||
SELECT
|
||||
TASK_ID,
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
USEC_TO_TIME(START_TS) AS START_TIMESTAMP,
|
||||
CASE
|
||||
@ -20571,6 +20584,7 @@ def_table_schema(
|
||||
SELECT
|
||||
TASK_ID,
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
USEC_TO_TIME(START_TS) AS START_TIMESTAMP,
|
||||
CASE
|
||||
@ -20623,6 +20637,7 @@ def_table_schema(
|
||||
SELECT
|
||||
BACKUP_SET_ID,
|
||||
DEST_ID,
|
||||
INCARNATION,
|
||||
BACKUP_TYPE,
|
||||
PREV_FULL_BACKUP_SET_ID,
|
||||
PREV_INC_BACKUP_SET_ID,
|
||||
@ -21131,6 +21146,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
EXECUTOR_TENANT_ID,
|
||||
@ -21167,6 +21183,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
EXECUTOR_TENANT_ID,
|
||||
@ -21203,6 +21220,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
TASK_ID,
|
||||
INCARNATION,
|
||||
JOB_ID,
|
||||
TASK_TYPE,
|
||||
ID,
|
||||
@ -21239,6 +21257,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
TASK_ID,
|
||||
INCARNATION,
|
||||
JOB_ID,
|
||||
TASK_TYPE,
|
||||
ID,
|
||||
@ -21525,6 +21544,7 @@ def_table_schema(
|
||||
SELECT
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -21618,6 +21638,7 @@ def_table_schema(
|
||||
SELECT
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -21696,6 +21717,7 @@ def_table_schema(
|
||||
(
|
||||
SELECT DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -21717,6 +21739,7 @@ SELECT DEST_ID,
|
||||
UNION
|
||||
SELECT DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
'STOP' AS STATUS,
|
||||
START_SCN,
|
||||
@ -21753,6 +21776,7 @@ def_table_schema(
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
PIECE_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -21863,6 +21887,7 @@ def_table_schema(
|
||||
TENANT_ID,
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -21955,6 +21980,7 @@ def_table_schema(
|
||||
TENANT_ID,
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -22034,6 +22060,7 @@ def_table_schema(
|
||||
SELECT TENANT_ID,
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -22056,6 +22083,7 @@ UNION
|
||||
SELECT TENANT_ID,
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
'STOP' AS STATUS,
|
||||
START_SCN,
|
||||
@ -38359,6 +38387,7 @@ def_table_schema(
|
||||
"""
|
||||
SELECT
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
@ -38400,6 +38429,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
@ -38442,6 +38472,7 @@ def_table_schema(
|
||||
SELECT
|
||||
TASK_ID,
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP,
|
||||
CASE
|
||||
@ -38496,6 +38527,7 @@ def_table_schema(
|
||||
SELECT
|
||||
TASK_ID,
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
BACKUP_SET_ID,
|
||||
TO_CHAR(START_TS / (1000 * 60 * 60 * 24 * 1000) + TO_DATE('1970-01-01 08:00:00', 'yyyy-mm-dd hh:mi:ss'), 'yyyy-mm-dd hh24:mi:ss') AS START_TIMESTAMP,
|
||||
CASE
|
||||
@ -38550,6 +38582,7 @@ def_table_schema(
|
||||
SELECT
|
||||
BACKUP_SET_ID,
|
||||
DEST_ID,
|
||||
INCARNATION,
|
||||
BACKUP_TYPE,
|
||||
PREV_FULL_BACKUP_SET_ID,
|
||||
PREV_INC_BACKUP_SET_ID,
|
||||
@ -38878,6 +38911,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
EXECUTOR_TENANT_ID,
|
||||
@ -38916,6 +38950,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
JOB_ID,
|
||||
INCARNATION,
|
||||
INITIATOR_TENANT_ID,
|
||||
INITIATOR_JOB_ID,
|
||||
EXECUTOR_TENANT_ID,
|
||||
@ -38954,6 +38989,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
TASK_ID,
|
||||
INCARNATION,
|
||||
JOB_ID,
|
||||
TASK_TYPE,
|
||||
ID,
|
||||
@ -38992,6 +39028,7 @@ def_table_schema(
|
||||
view_definition = """
|
||||
SELECT
|
||||
TASK_ID,
|
||||
INCARNATION,
|
||||
JOB_ID,
|
||||
TASK_TYPE,
|
||||
ID,
|
||||
@ -39219,6 +39256,7 @@ def_table_schema(
|
||||
SELECT
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -39304,6 +39342,7 @@ def_table_schema(
|
||||
SELECT
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -39372,6 +39411,7 @@ def_table_schema(
|
||||
(
|
||||
SELECT DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
@ -39393,6 +39433,7 @@ SELECT DEST_ID,
|
||||
UNION
|
||||
SELECT DEST_ID,
|
||||
ROUND_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
'STOP' AS STATUS,
|
||||
START_SCN,
|
||||
@ -39431,6 +39472,7 @@ def_table_schema(
|
||||
DEST_ID,
|
||||
ROUND_ID,
|
||||
PIECE_ID,
|
||||
INCARNATION,
|
||||
DEST_NO,
|
||||
STATUS,
|
||||
START_SCN,
|
||||
|
||||
@ -6029,8 +6029,7 @@ OB_SERIALIZE_MEMBER(ObCreateTabletInfo, tablet_ids_, data_tablet_id_, table_sche
|
||||
|
||||
bool ObBatchCreateTabletArg::is_inited() const
|
||||
{
|
||||
return id_.is_valid()
|
||||
&& OB_INVALID_TIMESTAMP != frozen_timestamp_;
|
||||
return id_.is_valid() && major_frozen_scn_.is_valid();
|
||||
}
|
||||
|
||||
bool ObBatchCreateTabletArg::is_valid() const
|
||||
@ -6060,7 +6059,7 @@ bool ObBatchCreateTabletArg::is_valid() const
|
||||
void ObBatchCreateTabletArg::reset()
|
||||
{
|
||||
id_.reset();
|
||||
frozen_timestamp_ = OB_INVALID_TIMESTAMP;
|
||||
major_frozen_scn_.reset();
|
||||
tablets_.reset();
|
||||
table_schemas_.reset();
|
||||
}
|
||||
@ -6077,7 +6076,7 @@ int ObBatchCreateTabletArg::assign(const ObBatchCreateTabletArg &arg)
|
||||
LOG_WARN("failed to assign table schema", KR(ret), K(arg));
|
||||
} else {
|
||||
id_ = arg.id_;
|
||||
frozen_timestamp_ = arg.frozen_timestamp_;
|
||||
major_frozen_scn_ = arg.major_frozen_scn_;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@ -6101,16 +6100,15 @@ int ObContextDDLArg::assign(const ObContextDDLArg &other)
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObBatchCreateTabletArg::init_create_tablet(const share::ObLSID &id, const int64_t &frozen_timestamp)
|
||||
int ObBatchCreateTabletArg::init_create_tablet(const share::ObLSID &id, const palf::SCN &major_frozen_scn)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
if (OB_UNLIKELY(!id.is_valid()
|
||||
|| OB_INVALID_TIMESTAMP == frozen_timestamp)) {
|
||||
if (OB_UNLIKELY(!id.is_valid() || !major_frozen_scn.is_valid())) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("invalid argument", KR(ret), K(id), K(frozen_timestamp));
|
||||
LOG_WARN("invalid argument", KR(ret), K(id), K(major_frozen_scn));
|
||||
} else {
|
||||
id_ = id;
|
||||
frozen_timestamp_ = frozen_timestamp;
|
||||
major_frozen_scn_ = major_frozen_scn;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@ -6128,11 +6126,11 @@ int64_t ObBatchCreateTabletArg::get_tablet_count() const
|
||||
DEF_TO_STRING(ObBatchCreateTabletArg)
|
||||
{
|
||||
int64_t pos = 0;
|
||||
J_KV(K_(id), K_(frozen_timestamp), K_(tablets));
|
||||
J_KV(K_(id), K_(major_frozen_scn), K_(tablets));
|
||||
return pos;
|
||||
}
|
||||
|
||||
OB_SERIALIZE_MEMBER(ObBatchCreateTabletArg, id_, frozen_timestamp_,
|
||||
OB_SERIALIZE_MEMBER(ObBatchCreateTabletArg, id_, major_frozen_scn_,
|
||||
tablets_, table_schemas_);
|
||||
|
||||
OB_SERIALIZE_MEMBER(ObCreateLSResult, ret_);
|
||||
|
||||
@ -2709,13 +2709,13 @@ public:
|
||||
void reset();
|
||||
int assign(const ObBatchCreateTabletArg &arg);
|
||||
int init_create_tablet(const share::ObLSID &id_,
|
||||
const int64_t &frozen_timestamp);
|
||||
const palf::SCN &major_frozen_scn);
|
||||
int64_t get_tablet_count() const;
|
||||
DECLARE_TO_STRING;
|
||||
|
||||
public:
|
||||
share::ObLSID id_;
|
||||
int64_t frozen_timestamp_;
|
||||
palf::SCN major_frozen_scn_;
|
||||
common::ObSArray<share::schema::ObTableSchema> table_schemas_;
|
||||
common::ObSArray<ObCreateTabletInfo> tablets_;
|
||||
};
|
||||
|
||||
@ -3826,6 +3826,11 @@ int ObTableSchema::check_alter_column_type(const ObColumnSchemaV2 &src_column,
|
||||
|| (src_meta.is_varbinary() && dst_meta.is_blob())
|
||||
|| (src_meta.is_text() && (dst_meta.is_text() || dst_meta.is_varchar()))
|
||||
|| (src_meta.is_blob() && (dst_meta.is_blob() || dst_meta.is_varbinary())))) {
|
||||
if (src_meta.is_integer_type() && dst_meta.is_integer_type()) {
|
||||
ret = OB_NOT_SUPPORTED;
|
||||
LOG_WARN("Type increment of integer type is not supported", K(ret), K(src_meta), K(dst_meta));
|
||||
LOG_USER_ERROR(OB_NOT_SUPPORTED, "Type increment of integer type is");
|
||||
}
|
||||
// online, do nothing
|
||||
} else {
|
||||
is_offline = true;
|
||||
|
||||
@ -5139,9 +5139,13 @@ int ObTableLocation::get_full_leader_table_loc(ObIAllocator &allocator,
|
||||
ObSchemaGetterGuard schema_guard;
|
||||
OZ(GCTX.schema_service_->get_tenant_schema_guard(tenant_id, schema_guard));
|
||||
OZ(schema_guard.get_table_schema(tenant_id, ref_table_id, table_schema));
|
||||
CK(OB_NOT_NULL(table_schema));
|
||||
OZ(table_schema->get_all_tablet_and_object_ids(tablet_ids, partition_ids));
|
||||
CK(table_schema->has_tablet());
|
||||
if (OB_ISNULL(table_schema)) {
|
||||
ret = OB_SCHEMA_ERROR;
|
||||
LOG_WARN("table schema is null", K(ret), K(table_id), K(tenant_id), K(ref_table_id));
|
||||
} else {
|
||||
OZ(table_schema->get_all_tablet_and_object_ids(tablet_ids, partition_ids));
|
||||
CK(table_schema->has_tablet());
|
||||
}
|
||||
if (OB_SUCC(ret)) {
|
||||
ObDASTableLocMeta *loc_meta = NULL;
|
||||
char *table_buf = static_cast<char*>(allocator.alloc(sizeof(ObDASTableLoc)
|
||||
|
||||
@ -3993,7 +3993,6 @@ int ObLSBackupPrepareTask::get_tablet_min_filled_tx_scn_(
|
||||
} else if (tablet->get_tablet_meta().tablet_id_.is_ls_inner_tablet()) {
|
||||
// skip inner tablet
|
||||
} else {
|
||||
min_filled_tx_scn = tablet->get_tablet_meta().clog_checkpoint_scn_;
|
||||
ObTabletTableStore &table_store = tablet->get_table_store();
|
||||
const ObSSTableArray &sstable_array = table_store.get_minor_sstables();
|
||||
has_minor_sstable = !sstable_array.empty();
|
||||
@ -4008,8 +4007,8 @@ int ObLSBackupPrepareTask::get_tablet_min_filled_tx_scn_(
|
||||
LOG_WARN("table ptr type not expectedd", K(ret));
|
||||
} else if (FALSE_IT(sstable = static_cast<ObSSTable *>(table_ptr))) {
|
||||
} else {
|
||||
palf::SCN filled_tx_scn = sstable->get_meta().get_basic_meta().filled_tx_scn_;
|
||||
min_filled_tx_scn = std::min(filled_tx_scn, min_filled_tx_scn);
|
||||
min_filled_tx_scn = std::min(
|
||||
std::max(sstable->get_meta().get_basic_meta().filled_tx_scn_, sstable->get_end_scn()), min_filled_tx_scn);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -255,7 +255,7 @@ int ObBackupUtils::check_tablet_minor_sstable_validity_(const storage::ObTabletH
|
||||
LOG_WARN("table ptr not correct", K(ret), KPC(last_table_ptr));
|
||||
} else {
|
||||
const ObITable::TableKey &table_key = last_table_ptr->get_key();
|
||||
if (table_key.get_end_scn() != clog_checkpoint_scn) {
|
||||
if (table_key.get_end_scn() < clog_checkpoint_scn) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_ERROR("tablet meta is not valid", K(ret), K(table_key), K(clog_checkpoint_scn));
|
||||
}
|
||||
|
||||
@ -75,7 +75,7 @@ public:
|
||||
|
||||
EncoderDesc &get_desc() { return desc_; }
|
||||
ObColumnHeader &get_column_header() { return column_header_; }
|
||||
|
||||
ObObjType get_obj_type() { return column_type_.get_type(); }
|
||||
// var data store only
|
||||
virtual int set_data_pos(const int64_t offset, const int64_t length)
|
||||
{
|
||||
|
||||
@ -521,15 +521,15 @@ int ObMicroBlockEncoder::store_encoding_meta_and_fix_cols(int64_t &encoding_meta
|
||||
if (OB_FAIL(encoders_.at(i)->store_meta(data_buffer_))) {
|
||||
LOG_WARN("store encoding meta failed", K(ret));
|
||||
} else {
|
||||
ObColumnHeader &ch = encoders_.at(i)->get_column_header();
|
||||
if (data_buffer_.pos() > pos_bak) {
|
||||
ObColumnHeader &ch = encoders_.at(i)->get_column_header();
|
||||
ch.offset_ = static_cast<uint32_t>(pos_bak - encoding_meta_offset);
|
||||
ch.length_ = static_cast<uint32_t>(data_buffer_.pos() - pos_bak);
|
||||
} else if (ObColumnHeader::RAW == encoders_.at(i)->get_type()) {
|
||||
// column header offset records the start pos of the fix data, if needed
|
||||
ObColumnHeader &ch = encoders_.at(i)->get_column_header();
|
||||
ch.offset_ = static_cast<uint32_t>(pos_bak - encoding_meta_offset);
|
||||
}
|
||||
ch.obj_type_ = static_cast<uint8_t>(encoders_.at(i)->get_obj_type());
|
||||
}
|
||||
|
||||
if (OB_SUCC(ret) && !desc.is_var_data_ && desc.need_data_store_) {
|
||||
|
||||
@ -293,7 +293,7 @@ struct ObColumnHeader
|
||||
int8_t version_;
|
||||
int8_t type_;
|
||||
int8_t attr_;
|
||||
int8_t reserved_;
|
||||
uint8_t obj_type_;
|
||||
union {
|
||||
uint32_t extend_value_offset_; // for var column null-bitmap stored continuously
|
||||
uint32_t extend_value_index_;
|
||||
@ -301,9 +301,16 @@ struct ObColumnHeader
|
||||
uint32_t offset_;
|
||||
uint32_t length_;
|
||||
|
||||
static_assert(UINT8_MAX >= ObObjType::ObMaxType, "ObObjType is stored in ObColumnHeader with 1 byte");
|
||||
ObColumnHeader() { reuse(); }
|
||||
void reuse() { memset(this, 0, sizeof(*this)); }
|
||||
bool is_valid() const { return version_ == OB_COLUMN_HEADER_V1 && type_ >= 0 && type_ < MAX_TYPE; }
|
||||
bool is_valid() const
|
||||
{
|
||||
return version_ == OB_COLUMN_HEADER_V1
|
||||
&& type_ >= 0
|
||||
&& type_ < MAX_TYPE
|
||||
&& obj_type_ < ObObjType::ObMaxType;
|
||||
}
|
||||
|
||||
inline bool is_fix_length() const { return attr_ & FIX_LENGTH; }
|
||||
inline bool has_extend_value() const { return attr_ & HAS_EXTEND_VALUE; }
|
||||
@ -318,6 +325,7 @@ struct ObColumnHeader
|
||||
{
|
||||
return COLUMN_EQUAL == type || COLUMN_SUBSTR == type;
|
||||
}
|
||||
inline ObObjType get_store_obj_type() const { return static_cast<ObObjType>(obj_type_); }
|
||||
|
||||
inline void set_fix_lenght_attr() { attr_ |= FIX_LENGTH; }
|
||||
inline void set_has_extend_value_attr() { attr_ |= HAS_EXTEND_VALUE; }
|
||||
@ -325,7 +333,8 @@ struct ObColumnHeader
|
||||
inline void set_last_var_field_attr() { attr_ |= LAST_VAR_FIELD; }
|
||||
inline void set_out_row() { attr_ |= OUT_ROW; }
|
||||
|
||||
TO_STRING_KV(K_(version), K_(type), K_(attr), K_(extend_value_offset), K_(offset), K_(length));
|
||||
TO_STRING_KV(K_(version), K_(type), K_(attr), K_(obj_type),
|
||||
K_(extend_value_offset), K_(offset), K_(length));
|
||||
} __attribute__((packed));
|
||||
|
||||
|
||||
|
||||
@ -785,6 +785,7 @@ int ObTabletMergeCtx::update_tablet_directly(const ObGetMergeTablesResult &get_m
|
||||
int ret = OB_SUCCESS;
|
||||
const int64_t rebuild_seq = ls_handle_.get_ls()->get_rebuild_seq();
|
||||
scn_range_ = get_merge_table_result.scn_range_;
|
||||
palf::SCN clog_checkpoint_scn = get_merge_table_result.scn_range_.end_scn_;
|
||||
|
||||
ObTableHandleV2 empty_table_handle;
|
||||
ObUpdateTableStoreParam param(
|
||||
@ -794,7 +795,7 @@ int ObTabletMergeCtx::update_tablet_directly(const ObGetMergeTablesResult &get_m
|
||||
schema_ctx_.storage_schema_,
|
||||
rebuild_seq,
|
||||
param_.is_major_merge(),
|
||||
palf::SCN::min_scn()/*clog_checkpoint_scn*/);
|
||||
clog_checkpoint_scn);
|
||||
ObTabletHandle new_tablet_handle;
|
||||
if (OB_FAIL(ls_handle_.get_ls()->update_tablet_table_store(
|
||||
param_.tablet_id_, param, new_tablet_handle))) {
|
||||
|
||||
@ -67,20 +67,20 @@ int ObTxTableMergeDag::init_by_param(const ObIDagInitParam *param)
|
||||
} else if (merge_param->tablet_id_.is_ls_tx_data_tablet() && merge_param->is_minor_merge()) {
|
||||
// init compaction filter for minor merge in TxDataTable
|
||||
ObTxTableGuard guard;
|
||||
int64_t recycle_ts = 0;
|
||||
palf::SCN recycle_scn = palf::SCN::min_scn();
|
||||
int tmp_ret = OB_SUCCESS;
|
||||
if (OB_TMP_FAIL(ctx_->ls_handle_.get_ls()->get_tx_table_guard(guard))) {
|
||||
LOG_WARN("failed to get tx table", K(tmp_ret), KPC(merge_param));
|
||||
} else if (OB_UNLIKELY(!guard.is_valid())) {
|
||||
tmp_ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("tx table guard is invalid", K(tmp_ret), KPC(merge_param), K(guard));
|
||||
} else if (OB_TMP_FAIL(guard.get_tx_table()->get_recycle_ts(recycle_ts))) {
|
||||
} else if (OB_TMP_FAIL(guard.get_tx_table()->get_recycle_scn(recycle_scn))) {
|
||||
LOG_WARN("failed to get recycle ts", K(tmp_ret), KPC(merge_param));
|
||||
} else if (OB_TMP_FAIL(compaction_filter_.init(recycle_ts, ObTxTable::get_filter_col_idx()))) {
|
||||
LOG_WARN("failed to get init compaction filter", K(tmp_ret), KPC(merge_param), K(recycle_ts));
|
||||
} else if (OB_TMP_FAIL(compaction_filter_.init(recycle_scn.get_val_for_tx(), ObTxTable::get_filter_col_idx()))) {
|
||||
LOG_WARN("failed to get init compaction filter", K(tmp_ret), KPC(merge_param), K(recycle_scn));
|
||||
} else {
|
||||
ctx_->compaction_filter_ = &compaction_filter_;
|
||||
FLOG_INFO("success to init compaction filter", K(tmp_ret), K(recycle_ts));
|
||||
FLOG_INFO("success to init compaction filter", K(tmp_ret), K(recycle_scn));
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
|
||||
@ -798,7 +798,8 @@ ObStartCompleteMigrationTask::ObStartCompleteMigrationTask()
|
||||
is_inited_(false),
|
||||
ls_handle_(),
|
||||
ctx_(nullptr),
|
||||
log_sync_scn_(palf::SCN::min_scn())
|
||||
log_sync_scn_(palf::SCN::min_scn()),
|
||||
max_minor_end_scn_(palf::SCN::min_scn())
|
||||
{
|
||||
}
|
||||
|
||||
@ -853,6 +854,8 @@ int ObStartCompleteMigrationTask::process()
|
||||
LOG_WARN("failed to check all tablet ready", K(ret), KPC(ctx_));
|
||||
} else if (OB_FAIL(wait_trans_tablet_explain_data_())) {
|
||||
LOG_WARN("failed to wait log replay sync", K(ret), KPC(ctx_));
|
||||
} else if (OB_FAIL(wait_ls_checkpoint_scn_push_())) {
|
||||
LOG_WARN("failed to wait ls checkpoint ts push", K(ret), KPC(ctx_));
|
||||
} else if (OB_FAIL(update_ls_migration_status_hold_())) {
|
||||
LOG_WARN("failed to update ls migration status hold", K(ret), KPC(ctx_));
|
||||
} else if (OB_FAIL(change_member_list_())) {
|
||||
@ -1256,6 +1259,12 @@ int ObStartCompleteMigrationTask::check_tablet_ready_(
|
||||
LOG_WARN("tablet should not be NULL", K(ret), KP(tablet), K(tablet_handle), K(tablet_id));
|
||||
} else if (tablet->get_tablet_meta().ha_status_.is_data_status_complete()
|
||||
|| !tablet->get_tablet_meta().ha_status_.is_restore_status_full()) {
|
||||
ObSSTableArray &minor_sstables = tablet->get_table_store().get_minor_sstables();
|
||||
if (minor_sstables.empty()) {
|
||||
max_minor_end_scn_ = MAX(max_minor_end_scn_, tablet->get_tablet_meta().clog_checkpoint_scn_);
|
||||
} else {
|
||||
max_minor_end_scn_ = MAX(max_minor_end_scn_, minor_sstables.array_[minor_sstables.count() - 1]->get_end_scn());
|
||||
}
|
||||
break;
|
||||
} else {
|
||||
const int64_t current_ts = ObTimeUtility::current_time();
|
||||
@ -1286,6 +1295,103 @@ int ObStartCompleteMigrationTask::check_tablet_ready_(
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObStartCompleteMigrationTask::check_need_wait_checkpoint_scn_push_(
|
||||
ObLS *ls,
|
||||
bool &need_wait)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
need_wait = true;
|
||||
|
||||
if (!is_inited_) {
|
||||
ret = OB_NOT_INIT;
|
||||
LOG_WARN("start complete migration task do not init", K(ret));
|
||||
} else if (OB_ISNULL(ls)) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("check need wait log sync get invalid argument", K(ret), KP(ls));
|
||||
} else if (ObMigrationOpType::ADD_LS_OP == ctx_->arg_.type_
|
||||
|| ObMigrationOpType::MIGRATE_LS_OP == ctx_->arg_.type_) {
|
||||
need_wait = true;
|
||||
ObLSRestoreStatus ls_restore_status;
|
||||
if (OB_FAIL(ls->get_restore_status(ls_restore_status))) {
|
||||
LOG_WARN("failed to get restore status", K(ret), KPC(ctx_));
|
||||
} else if (!ls_restore_status.is_in_restore()) {
|
||||
need_wait = true;
|
||||
} else if (!ls_restore_status.can_restore_log()) {
|
||||
need_wait = false;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
//TODO(muwei.ym) remove it later
|
||||
int ObStartCompleteMigrationTask::wait_ls_checkpoint_scn_push_()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObLSHandle ls_handle;
|
||||
ObLS *ls = nullptr;
|
||||
checkpoint::ObCheckpointExecutor *checkpoint_executor = NULL;
|
||||
const int64_t MAX_WAIT_INTERVAL_BY_CHECKPOINT_BY_FLUSH = GCONF._advance_checkpoint_timeout;
|
||||
const int64_t MAX_SLEEP_INTERVAL_MS = 1 * 1000 * 1000; //1s
|
||||
bool is_cancel = false;
|
||||
bool need_wait = true;
|
||||
|
||||
if (!is_inited_) {
|
||||
ret = OB_NOT_INIT;
|
||||
LOG_WARN("start complete migration task do not init", K(ret));
|
||||
} else if (OB_FAIL(ObStorageHADagUtils::get_ls(ctx_->arg_.ls_id_, ls_handle))) {
|
||||
LOG_WARN("failed to get ls", K(ret), KPC(ctx_));
|
||||
} else if (OB_ISNULL(ls = ls_handle.get_ls())) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("ls should not be NULL", K(ret), KP(ls), KPC(ctx_));
|
||||
} else if (OB_FAIL(check_need_wait_checkpoint_scn_push_(ls, need_wait))) {
|
||||
LOG_WARN("failed to check need wait log sync", K(ret), KPC(ls), KPC(ctx_));
|
||||
} else if (!need_wait) {
|
||||
LOG_INFO("no need to wait ls checkpoint ts push", K(ret), KPC(ctx_));
|
||||
} else if (OB_ISNULL(checkpoint_executor = ls->get_checkpoint_executor())) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("checkpoint executor should not be NULL", K(ret), KPC(ctx_), KP(checkpoint_executor));
|
||||
} else {
|
||||
const int64_t wait_checkpoint_push_start_ts = ObTimeUtility::current_time();
|
||||
palf::SCN checkpoint_scn = palf::SCN::min_scn();
|
||||
while (OB_SUCC(ret)) {
|
||||
if (ctx_->is_failed()) {
|
||||
ret = OB_CANCELED;
|
||||
STORAGE_LOG(WARN, "ls migration task is failed, cancel wait ls check point ts push", K(ret));
|
||||
} else if (OB_FAIL(SYS_TASK_STATUS_MGR.is_task_cancel(get_dag()->get_dag_id(), is_cancel))) {
|
||||
STORAGE_LOG(ERROR, "failed to check is task canceled", K(ret), K(*this));
|
||||
} else if (is_cancel) {
|
||||
ret = OB_CANCELED;
|
||||
STORAGE_LOG(WARN, "task is cancelled", K(ret), K(*this));
|
||||
} else if (FALSE_IT(checkpoint_scn = ls->get_clog_checkpoint_scn())) {
|
||||
} else if (checkpoint_scn >= max_minor_end_scn_) {
|
||||
const int64_t cost_ts = ObTimeUtility::current_time() - wait_checkpoint_push_start_ts;
|
||||
LOG_INFO("succeed wait clog checkpoint ts push", "cost", cost_ts, "ls_id", ctx_->arg_.ls_id_);
|
||||
break;
|
||||
} else if (OB_FAIL(checkpoint_executor->advance_checkpoint_by_flush(max_minor_end_scn_))) {
|
||||
if (OB_NO_NEED_UPDATE == ret) {
|
||||
ret = OB_SUCCESS;
|
||||
} else {
|
||||
LOG_WARN("failed to advance checkpoint by flush", K(ret), KPC(ctx_));
|
||||
}
|
||||
}
|
||||
|
||||
if (OB_SUCC(ret)) {
|
||||
const int64_t current_ts = ObTimeUtility::current_time();
|
||||
if (current_ts - wait_checkpoint_push_start_ts >= MAX_WAIT_INTERVAL_BY_CHECKPOINT_BY_FLUSH) {
|
||||
ret = OB_TIMEOUT;
|
||||
LOG_WARN("wait ls checkpoint ts push time out",
|
||||
"ls_checkpoint_scn", checkpoint_scn, "need_checkpoint_scn", max_minor_end_scn_, "ls_id", ctx_->arg_.ls_id_);
|
||||
} else {
|
||||
LOG_INFO("wait ls checkpoint ts push", "ls_checkpoint_scn", checkpoint_scn,
|
||||
"need_checkpoint_scn", max_minor_end_scn_, "ls_id", ctx_->arg_.ls_id_);
|
||||
ob_usleep(MAX_SLEEP_INTERVAL_MS);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObStartCompleteMigrationTask::record_server_event_()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
|
||||
@ -181,6 +181,10 @@ private:
|
||||
int check_tablet_ready_(
|
||||
const common::ObTabletID &tablet_id,
|
||||
ObLS *ls);
|
||||
int check_need_wait_checkpoint_scn_push_(
|
||||
ObLS *ls,
|
||||
bool &need_wait);
|
||||
int wait_ls_checkpoint_scn_push_();
|
||||
int record_server_event_();
|
||||
|
||||
private:
|
||||
@ -188,6 +192,7 @@ private:
|
||||
ObLSHandle ls_handle_;
|
||||
ObLSCompleteMigrationCtx *ctx_;
|
||||
palf::SCN log_sync_scn_;
|
||||
palf::SCN max_minor_end_scn_;
|
||||
DISALLOW_COPY_AND_ASSIGN(ObStartCompleteMigrationTask);
|
||||
};
|
||||
|
||||
|
||||
@ -36,8 +36,6 @@ ObMigrationCtx::ObMigrationCtx()
|
||||
: ObIHADagNetCtx(),
|
||||
tenant_id_(OB_INVALID_ID),
|
||||
arg_(),
|
||||
local_clog_checkpoint_ts_(0),
|
||||
local_rebuild_seq_(0),
|
||||
start_ts_(0),
|
||||
finish_ts_(0),
|
||||
task_id_(),
|
||||
@ -49,6 +47,7 @@ ObMigrationCtx::ObMigrationCtx()
|
||||
ha_table_info_mgr_(),
|
||||
check_tablet_info_cost_time_(0)
|
||||
{
|
||||
local_clog_checkpoint_scn_.set_min();
|
||||
}
|
||||
|
||||
ObMigrationCtx::~ObMigrationCtx()
|
||||
@ -65,7 +64,7 @@ void ObMigrationCtx::reset()
|
||||
{
|
||||
tenant_id_ = OB_INVALID_ID;
|
||||
arg_.reset();
|
||||
local_clog_checkpoint_ts_ = 0;
|
||||
local_clog_checkpoint_scn_.set_min();
|
||||
local_rebuild_seq_ = 0;
|
||||
start_ts_ = 0;
|
||||
finish_ts_ = 0;
|
||||
@ -109,7 +108,7 @@ int ObMigrationCtx::fill_comment(char *buf, const int64_t buf_len) const
|
||||
|
||||
void ObMigrationCtx::reuse()
|
||||
{
|
||||
local_clog_checkpoint_ts_ = 0;
|
||||
local_clog_checkpoint_scn_.set_min();
|
||||
local_rebuild_seq_ = 0;
|
||||
minor_src_.reset();
|
||||
major_src_.reset();
|
||||
@ -1052,7 +1051,7 @@ int ObStartMigrationTask::deal_with_local_ls_()
|
||||
if (OB_FAIL(ls->get_ls_meta(local_ls_meta))) {
|
||||
LOG_WARN("failed to get ls meta", K(ret), "arg", ctx_->arg_);
|
||||
} else {
|
||||
ctx_->local_clog_checkpoint_ts_ = local_ls_meta.get_clog_checkpoint_ts();
|
||||
ctx_->local_clog_checkpoint_scn_ = local_ls_meta.get_clog_checkpoint_scn();
|
||||
ctx_->local_rebuild_seq_ = local_ls_meta.get_rebuild_seq();
|
||||
common::ObReplicaType replica_type = ctx_->arg_.dst_.get_replica_type();
|
||||
common::ObReplicaType local_replica_type = ls->get_replica_type();
|
||||
@ -1082,13 +1081,13 @@ int ObStartMigrationTask::choose_src_()
|
||||
const share::ObLSID &ls_id = ctx_->arg_.ls_id_;
|
||||
ObStorageHASrcInfo src_info;
|
||||
obrpc::ObCopyLSInfo ls_info;
|
||||
int64_t local_clog_checkpoint_ts = 0;
|
||||
if (OB_FAIL(get_local_ls_checkpoint_ts_(local_clog_checkpoint_ts))) {
|
||||
palf::SCN local_clog_checkpoint_scn = palf::SCN::min_scn();
|
||||
if (OB_FAIL(get_local_ls_checkpoint_scn_(local_clog_checkpoint_scn))) {
|
||||
LOG_WARN("failed to get local ls checkpoint ts", K(ret));
|
||||
} else if (OB_FAIL(src_provider.init(tenant_id, storage_rpc_))) {
|
||||
LOG_WARN("failed to init src provider", K(ret), K(tenant_id));
|
||||
} else if (OB_FAIL(src_provider.choose_ob_src(ls_id, local_clog_checkpoint_ts, src_info))) {
|
||||
LOG_WARN("failed to choose ob src", K(ret), K(tenant_id), K(ls_id), K(local_clog_checkpoint_ts));
|
||||
} else if (OB_FAIL(src_provider.choose_ob_src(ls_id, local_clog_checkpoint_scn, src_info))) {
|
||||
LOG_WARN("failed to choose ob src", K(ret), K(tenant_id), K(ls_id), K(local_clog_checkpoint_scn));
|
||||
} else if (OB_FAIL(fetch_ls_info_(tenant_id, ls_id, src_info.src_addr_, ls_info))) {
|
||||
LOG_WARN("failed to fetch ls info", K(ret), K(tenant_id), K(ls_id), K(src_info));
|
||||
} else {
|
||||
@ -1135,10 +1134,10 @@ int ObStartMigrationTask::fetch_ls_info_(const uint64_t tenant_id, const share::
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObStartMigrationTask::get_local_ls_checkpoint_ts_(int64_t &local_checkpoint_ts)
|
||||
int ObStartMigrationTask::get_local_ls_checkpoint_scn_(palf::SCN &local_checkpoint_scn)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
local_checkpoint_ts = 0;
|
||||
local_checkpoint_scn.set_min();
|
||||
ObLSHandle ls_handle;
|
||||
ObLS *ls = NULL;
|
||||
ObLSMeta local_ls_meta;
|
||||
@ -1153,7 +1152,7 @@ int ObStartMigrationTask::get_local_ls_checkpoint_ts_(int64_t &local_checkpoint_
|
||||
} else if (OB_FAIL(ls->get_ls_meta(local_ls_meta))) {
|
||||
LOG_WARN("failed to get ls meta", K(ret), "arg", ctx_->arg_);
|
||||
} else {
|
||||
local_checkpoint_ts = local_ls_meta.get_clog_checkpoint_ts();
|
||||
local_checkpoint_scn = local_ls_meta.get_clog_checkpoint_scn();
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@ -1189,7 +1188,7 @@ int ObStartMigrationTask::update_ls_()
|
||||
} else if (OB_FAIL(ls->advance_base_info(ctx_->src_ls_meta_package_.palf_meta_, is_rebuild))) {
|
||||
LOG_WARN("failed to advance base lsn for migration", K(ret), KPC(ctx_));
|
||||
} else {
|
||||
ctx_->local_clog_checkpoint_ts_ = ctx_->src_ls_meta_package_.ls_meta_.get_clog_checkpoint_ts();
|
||||
ctx_->local_clog_checkpoint_scn_ = ctx_->src_ls_meta_package_.ls_meta_.get_clog_checkpoint_scn();
|
||||
ctx_->local_rebuild_seq_ = ctx_->src_ls_meta_package_.ls_meta_.get_rebuild_seq();
|
||||
}
|
||||
}
|
||||
@ -2106,13 +2105,11 @@ int ObTabletMigrationDag::inner_reset_status_for_retry()
|
||||
"ls_id", ctx->arg_.ls_id_.id(),
|
||||
"tablet_id", copy_tablet_ctx_.tablet_id_,
|
||||
"result", result, "retry_count", retry_count);
|
||||
if (OB_SSTABLE_NOT_EXIST == result) {
|
||||
if (OB_FAIL(ctx->ha_table_info_mgr_.remove_tablet_table_info(copy_tablet_ctx_.tablet_id_))) {
|
||||
if (OB_HASH_NOT_EXIST == ret) {
|
||||
ret = OB_SUCCESS;
|
||||
} else {
|
||||
LOG_WARN("failed to remove tablet info", K(ret), KPC(ctx), K(copy_tablet_ctx_));
|
||||
}
|
||||
if (OB_FAIL(ctx->ha_table_info_mgr_.remove_tablet_table_info(copy_tablet_ctx_.tablet_id_))) {
|
||||
if (OB_HASH_NOT_EXIST == ret) {
|
||||
ret = OB_SUCCESS;
|
||||
} else {
|
||||
LOG_WARN("failed to remove tablet info", K(ret), KPC(ctx), K(copy_tablet_ctx_));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -20,6 +20,7 @@
|
||||
#include "share/scheduler/ob_sys_task_stat.h"
|
||||
#include "observer/ob_rpc_processor_simple.h"
|
||||
#include "share/scheduler/ob_dag_scheduler.h"
|
||||
#include "logservice/palf/scn.h"
|
||||
#include "storage/ob_storage_rpc.h"
|
||||
#include "ob_storage_ha_struct.h"
|
||||
#include "ob_physical_copy_task.h"
|
||||
@ -46,7 +47,7 @@ public:
|
||||
public:
|
||||
uint64_t tenant_id_;
|
||||
ObMigrationOpArg arg_;
|
||||
int64_t local_clog_checkpoint_ts_;
|
||||
palf::SCN local_clog_checkpoint_scn_;
|
||||
int64_t local_rebuild_seq_;
|
||||
|
||||
int64_t start_ts_;
|
||||
@ -64,7 +65,7 @@ public:
|
||||
INHERIT_TO_STRING_KV(
|
||||
"ObIHADagNetCtx", ObIHADagNetCtx,
|
||||
K_(arg),
|
||||
K_(local_clog_checkpoint_ts),
|
||||
K_(local_clog_checkpoint_scn),
|
||||
K_(local_rebuild_seq),
|
||||
K_(start_ts),
|
||||
K_(finish_ts),
|
||||
@ -235,7 +236,7 @@ private:
|
||||
int choose_src_();
|
||||
int fetch_ls_info_(const uint64_t tenant_id, const share::ObLSID &ls_id,
|
||||
const common::ObAddr &member_addr, obrpc::ObCopyLSInfo &ls_info);
|
||||
int get_local_ls_checkpoint_ts_(int64_t &local_checkpoint_ts);
|
||||
int get_local_ls_checkpoint_scn_(palf::SCN &local_checkpoint_scn);
|
||||
int try_remove_member_list_();
|
||||
int get_tablet_id_array_(common::ObIArray<common::ObTabletID> &tablet_id_array);
|
||||
int check_ls_need_copy_data_(bool &need_copy);
|
||||
|
||||
@ -556,9 +556,11 @@ int ObStorageHATaskUtils::check_need_copy_sstable(
|
||||
LOG_WARN("failed to check major sstable need copy", K(ret), K(param), K(tablet_handle));
|
||||
}
|
||||
} else if (param.table_key_.is_minor_sstable()) {
|
||||
if (OB_FAIL(check_minor_sstable_need_copy_(param, tablet_handle, need_copy))) {
|
||||
LOG_WARN("failed to check minor sstable need copy", K(ret), K(param), K(tablet_handle));
|
||||
}
|
||||
need_copy = true;
|
||||
//TODO(muwei.ym) reuse local minor sstable
|
||||
//if (OB_FAIL(check_minor_sstable_need_copy_(param, tablet_handle, need_copy))) {
|
||||
// LOG_WARN("failed to check minor sstable need copy", K(ret), K(param), K(tablet_handle));
|
||||
//}
|
||||
} else if (param.table_key_.is_ddl_sstable()) {
|
||||
if (OB_FAIL(check_ddl_sstable_need_copy_(param, tablet_handle, need_copy))) {
|
||||
LOG_WARN("failed to check ddl sstable need copy", K(ret), K(param), K(tablet_handle));
|
||||
|
||||
@ -41,7 +41,7 @@ int ObStorageHASrcProvider::init(const uint64_t tenant_id, storage::ObStorageRpc
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObStorageHASrcProvider::choose_ob_src(const share::ObLSID &ls_id, const int64_t local_clog_checkpoint_ts,
|
||||
int ObStorageHASrcProvider::choose_ob_src(const share::ObLSID &ls_id, const palf::SCN &local_clog_checkpoint_scn,
|
||||
ObStorageHASrcInfo &src_info)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
@ -57,8 +57,8 @@ int ObStorageHASrcProvider::choose_ob_src(const share::ObLSID &ls_id, const int6
|
||||
LOG_WARN("failed to get ls leader", K(ret), K_(tenant_id), K(ls_id));
|
||||
} else if (OB_FAIL(fetch_ls_member_list_(tenant_id_, ls_id, leader_addr, addr_list))) {
|
||||
LOG_WARN("failed to fetch ls leader member list", K(ret), K_(tenant_id), K(ls_id), K(leader_addr));
|
||||
} else if (OB_FAIL(inner_choose_ob_src_(tenant_id_, ls_id, local_clog_checkpoint_ts, addr_list, chosen_src_addr))) {
|
||||
LOG_WARN("failed to inner choose ob src", K(ret), K_(tenant_id), K(ls_id), K(local_clog_checkpoint_ts), K(addr_list));
|
||||
} else if (OB_FAIL(inner_choose_ob_src_(tenant_id_, ls_id, local_clog_checkpoint_scn, addr_list, chosen_src_addr))) {
|
||||
LOG_WARN("failed to inner choose ob src", K(ret), K_(tenant_id), K(ls_id), K(local_clog_checkpoint_scn), K(addr_list));
|
||||
} else {
|
||||
src_info.src_addr_ = chosen_src_addr;
|
||||
src_info.cluster_id_ = GCONF.cluster_id;
|
||||
@ -156,13 +156,13 @@ int ObStorageHASrcProvider::fetch_ls_meta_info_(const uint64_t tenant_id, const
|
||||
}
|
||||
|
||||
int ObStorageHASrcProvider::inner_choose_ob_src_(const uint64_t tenant_id, const share::ObLSID &ls_id,
|
||||
const int64_t local_clog_checkpoint_ts, const common::ObIArray<common::ObAddr> &addr_list,
|
||||
const palf::SCN &local_clog_checkpoint_scn, const common::ObIArray<common::ObAddr> &addr_list,
|
||||
common::ObAddr &choosen_src_addr)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
int tmp_ret = OB_SUCCESS;
|
||||
int64_t choose_member_idx = -1;
|
||||
int64_t max_clog_checkpoint_ts = -1;
|
||||
palf::SCN max_clog_checkpoint_scn;
|
||||
for (int64_t i = 0; OB_SUCC(ret) && i < addr_list.count(); ++i) {
|
||||
const common::ObAddr &addr = addr_list.at(i);
|
||||
obrpc::ObFetchLSMetaInfoResp ls_info;
|
||||
@ -172,8 +172,8 @@ int ObStorageHASrcProvider::inner_choose_ob_src_(const uint64_t tenant_id, const
|
||||
LOG_WARN("failed to fetch ls meta info", K(ret), K(tenant_id), K(ls_id), K(addr));
|
||||
} else if (!ObReplicaTypeCheck::is_full_replica(ls_info.ls_meta_package_.ls_meta_.replica_type_)) {
|
||||
LOG_INFO("do not choose this src", K(tenant_id), K(ls_id), K(addr), K(ls_info));
|
||||
} else if (local_clog_checkpoint_ts > ls_info.ls_meta_package_.ls_meta_.get_clog_checkpoint_ts()) {
|
||||
LOG_INFO("do not choose this src", K(tenant_id), K(ls_id), K(addr), K(local_clog_checkpoint_ts), K(ls_info));
|
||||
} else if (local_clog_checkpoint_scn > ls_info.ls_meta_package_.ls_meta_.get_clog_checkpoint_scn()) {
|
||||
LOG_INFO("do not choose this src", K(tenant_id), K(ls_id), K(addr), K(local_clog_checkpoint_scn), K(ls_info));
|
||||
} else if (OB_FAIL(ls_info.ls_meta_package_.ls_meta_.get_migration_status(migration_status))) {
|
||||
LOG_WARN("failed to get migration status", K(ret), K(ls_info));
|
||||
} else if (!ObMigrationStatusHelper::check_can_migrate_out(migration_status)) {
|
||||
@ -185,8 +185,8 @@ int ObStorageHASrcProvider::inner_choose_ob_src_(const uint64_t tenant_id, const
|
||||
LOG_INFO("some ls replica restore failed, can not migrate", K(ls_info));
|
||||
break;
|
||||
} else {
|
||||
if (ls_info.ls_meta_package_.ls_meta_.get_clog_checkpoint_ts() > max_clog_checkpoint_ts) {
|
||||
max_clog_checkpoint_ts = ls_info.ls_meta_package_.ls_meta_.get_clog_checkpoint_ts();
|
||||
if (ls_info.ls_meta_package_.ls_meta_.get_clog_checkpoint_scn() > max_clog_checkpoint_scn) {
|
||||
max_clog_checkpoint_scn = ls_info.ls_meta_package_.ls_meta_.get_clog_checkpoint_scn();
|
||||
choose_member_idx = i;
|
||||
}
|
||||
}
|
||||
|
||||
@ -25,7 +25,7 @@ public:
|
||||
ObStorageHASrcProvider();
|
||||
virtual ~ObStorageHASrcProvider();
|
||||
int init(const uint64_t tenant_id, storage::ObStorageRpc *storage_rpc);
|
||||
int choose_ob_src(const share::ObLSID &ls_id, const int64_t local_clog_checkpoint_ts,
|
||||
int choose_ob_src(const share::ObLSID &ls_id, const palf::SCN &local_clog_checkpoint_scn,
|
||||
ObStorageHASrcInfo &src_info);
|
||||
|
||||
private:
|
||||
@ -33,7 +33,7 @@ private:
|
||||
int fetch_ls_member_list_(const uint64_t tenant_id, const share::ObLSID &ls_id, const common::ObAddr &addr,
|
||||
common::ObIArray<common::ObAddr> &addr_list);
|
||||
int inner_choose_ob_src_(const uint64_t tenant_id, const share::ObLSID &ls_id,
|
||||
const int64_t local_clog_checkpoint_ts, const common::ObIArray<common::ObAddr> &addr_list,
|
||||
const palf::SCN &local_clog_checkpoint_scn, const common::ObIArray<common::ObAddr> &addr_list,
|
||||
common::ObAddr &choosen_src_addr);
|
||||
int fetch_ls_meta_info_(const uint64_t tenant_id, const share::ObLSID &ls_id, const common::ObAddr &member_addr,
|
||||
obrpc::ObFetchLSMetaInfoResp &ls_meta_info);
|
||||
|
||||
@ -1468,8 +1468,8 @@ int ObStorageHATableInfoMgr::check_tablet_table_info_exist(
|
||||
} else {
|
||||
LOG_WARN("failed to get tablet table info mgr", K(ret), K(tablet_id));
|
||||
}
|
||||
} else {
|
||||
is_exist = true;
|
||||
} else if (OB_FAIL(tablet_table_info_mgr->check_copy_tablet_exist(is_exist))) {
|
||||
LOG_WARN("failed to check copy tablet exist", K(ret), K(tablet_id));
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
|
||||
@ -116,8 +116,11 @@ ObTabletRestoreCtx::~ObTabletRestoreCtx()
|
||||
|
||||
bool ObTabletRestoreCtx::is_valid() const
|
||||
{
|
||||
return tenant_id_ != OB_INVALID_ID && ls_id_.is_valid() && tablet_id_.is_valid() && tablet_handle_.is_valid()
|
||||
&& ObCopyTabletStatus::is_valid(status_) && OB_NOT_NULL(restore_base_info_)
|
||||
return tenant_id_ != OB_INVALID_ID && ls_id_.is_valid() && tablet_id_.is_valid()
|
||||
&& ObCopyTabletStatus::is_valid(status_)
|
||||
&& ((ObCopyTabletStatus::TABLET_EXIST == status_ && tablet_handle_.is_valid())
|
||||
|| ObCopyTabletStatus::TABLET_NOT_EXIST == status_)
|
||||
&& OB_NOT_NULL(restore_base_info_)
|
||||
&& ObTabletRestoreAction::is_valid(action_)
|
||||
&& (!is_leader_ || OB_NOT_NULL(second_meta_index_store_))
|
||||
&& ObReplicaTypeCheck::is_replica_type_valid(replica_type_)
|
||||
@ -1685,7 +1688,7 @@ ObTabletRestoreDag::~ObTabletRestoreDag()
|
||||
if (OB_NOT_NULL(tablet_restore_ctx_.ha_table_info_mgr_)) {
|
||||
if (OB_SUCCESS != (tmp_ret = tablet_restore_ctx_.ha_table_info_mgr_->remove_tablet_table_info(
|
||||
tablet_restore_ctx_.tablet_id_))) {
|
||||
LOG_ERROR("failed to remove tablet table info", K(tmp_ret), K(tablet_restore_ctx_));
|
||||
LOG_WARN("failed to remove tablet table info", K(tmp_ret), K(tablet_restore_ctx_));
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1863,7 +1866,7 @@ int ObTabletRestoreDag::inner_reset_status_for_retry()
|
||||
} else {
|
||||
LOG_INFO("start retry", KPC(this));
|
||||
result_mgr_.reuse();
|
||||
if (OB_SSTABLE_NOT_EXIST == result && !tablet_restore_ctx_.is_leader_) {
|
||||
if (!tablet_restore_ctx_.is_leader_) {
|
||||
if (OB_FAIL(tablet_restore_ctx_.ha_table_info_mgr_->remove_tablet_table_info(tablet_restore_ctx_.tablet_id_))) {
|
||||
LOG_WARN("failed to remove tablet info", K(ret), K(tablet_restore_ctx_));
|
||||
}
|
||||
|
||||
@ -109,7 +109,6 @@ namespace storage
|
||||
return ret; \
|
||||
}
|
||||
|
||||
const static int64_t LS_INNER_TABLET_FROZEN_TIMESTAMP = 1;
|
||||
|
||||
struct ObLSVTInfo
|
||||
{
|
||||
|
||||
@ -1592,7 +1592,6 @@ int ObLSTabletService::build_single_data_tablet(
|
||||
common::ObIArray<ObTabletHandle> &tablet_handle_array)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
palf::SCN snapshot_version;
|
||||
const common::ObTabletID &data_tablet_id = info.data_tablet_id_;
|
||||
const common::ObSArray<common::ObTabletID> &tablet_ids = info.tablet_ids_;
|
||||
const common::ObSArray<share::schema::ObTableSchema> &table_schemas = arg.table_schemas_;
|
||||
@ -1607,13 +1606,11 @@ int ObLSTabletService::build_single_data_tablet(
|
||||
} else if (OB_UNLIKELY(index < 0)) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("unexpected error, table schema index is invalid", K(ret), K(data_tablet_id), K(index));
|
||||
} else if (OB_FAIL(snapshot_version.convert_for_lsn_allocator(arg.frozen_timestamp_))) {
|
||||
STORAGE_LOG(WARN, "fail to convert to scn", KR(ret), K(create_scn));
|
||||
} else if (OB_FAIL(do_create_tablet(ls_id, data_tablet_id, data_tablet_id, empty_array,
|
||||
create_scn, snapshot_version, table_schemas[info.table_schema_index_[index]],
|
||||
create_scn, arg.major_frozen_scn_, table_schemas[info.table_schema_index_[index]],
|
||||
compat_mode, empty_tablet_id, empty_tablet_id, tablet_handle))) {
|
||||
LOG_WARN("failed to do create tablet", K(ret), K(ls_id), K(data_tablet_id),
|
||||
K(create_scn), K(snapshot_version), K(compat_mode));
|
||||
K(create_scn), K(arg), K(compat_mode));
|
||||
} else if (OB_FAIL(tablet_handle_array.push_back(tablet_handle))) {
|
||||
LOG_WARN("failed to insert tablet handle into array", K(ret), K(tablet_handle));
|
||||
}
|
||||
@ -1669,7 +1666,7 @@ int ObLSTabletService::build_batch_create_tablet_arg(
|
||||
if (OB_FAIL(ret)) { // do nothing
|
||||
} else {
|
||||
new_arg.id_ = old_arg.id_;
|
||||
new_arg.frozen_timestamp_ = old_arg.frozen_timestamp_;
|
||||
new_arg.major_frozen_scn_ = old_arg.major_frozen_scn_;
|
||||
|
||||
if (new_arg.get_tablet_count() > 0 && OB_FAIL(new_arg.table_schemas_.assign(old_arg.table_schemas_))) {
|
||||
LOG_WARN("failed to assign table schemas", K(ret), K(old_arg));
|
||||
@ -5123,7 +5120,7 @@ int ObLSTabletService::create_ls_inner_tablet(
|
||||
const share::ObLSID &ls_id,
|
||||
const common::ObTabletID &tablet_id,
|
||||
const int64_t memstore_version,
|
||||
const palf::SCN &frozen_timestamp,
|
||||
const palf::SCN &major_frozen_scn,
|
||||
const share::schema::ObTableSchema &table_schema,
|
||||
const lib::Worker::CompatMode &compat_mode,
|
||||
const palf::SCN &create_scn)
|
||||
@ -5142,12 +5139,12 @@ int ObLSTabletService::create_ls_inner_tablet(
|
||||
} else if (OB_UNLIKELY(!ls_id.is_valid())
|
||||
|| OB_UNLIKELY(!tablet_id.is_valid())
|
||||
|| OB_UNLIKELY(OB_INVALID_VERSION == memstore_version)
|
||||
|| OB_UNLIKELY(!frozen_timestamp.is_valid())
|
||||
|| OB_UNLIKELY(!major_frozen_scn.is_valid())
|
||||
|| OB_UNLIKELY(!table_schema.is_valid())
|
||||
|| OB_UNLIKELY(lib::Worker::CompatMode::INVALID == compat_mode)
|
||||
/*|| OB_UNLIKELY(create_scn <= OB_INVALID_TIMESTAMP)*/) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("invalid args", K(ret), K(ls_id), K(tablet_id), K(frozen_timestamp),
|
||||
LOG_WARN("invalid args", K(ret), K(ls_id), K(tablet_id), K(major_frozen_scn),
|
||||
K(table_schema), K(compat_mode), K(create_scn));
|
||||
} else if (OB_UNLIKELY(ls_id != ls_->get_ls_id())) {
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
@ -5161,9 +5158,9 @@ int ObLSTabletService::create_ls_inner_tablet(
|
||||
ret = OB_TABLET_EXIST;
|
||||
LOG_WARN("tablet already exists", K(ret), K(ls_id), K(tablet_id));
|
||||
} else if (OB_FAIL(do_create_tablet(ls_id, tablet_id, tablet_id/*data_tablet_id*/, empty_index_tablet_array,
|
||||
create_scn, frozen_timestamp, table_schema, compat_mode, empty_tablet_id, empty_tablet_id, tablet_handle))) {
|
||||
create_scn, major_frozen_scn, table_schema, compat_mode, empty_tablet_id, empty_tablet_id, tablet_handle))) {
|
||||
LOG_WARN("failed to do create tablet", K(ret), K(ls_id), K(tablet_id),
|
||||
K(create_scn), K(frozen_timestamp), K(table_schema), K(compat_mode));
|
||||
K(create_scn), K(major_frozen_scn), K(table_schema), K(compat_mode));
|
||||
} else if (OB_FAIL(ObTabletSlogHelper::write_create_tablet_slog(tablet_handle, disk_addr))) {
|
||||
LOG_WARN("failed to write create tablet slog", K(ret), K(tablet_handle));
|
||||
} else if (OB_FAIL(tablet_id_set_.set(tablet_id))) {
|
||||
|
||||
@ -340,10 +340,10 @@ int ObBatchUpdateTableStoreParam::assign(
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObBatchUpdateTableStoreParam::get_max_clog_checkpoint_ts(int64_t &clog_checkpoint_ts) const
|
||||
int ObBatchUpdateTableStoreParam::get_max_clog_checkpoint_scn(palf::SCN &clog_checkpoint_scn) const
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
clog_checkpoint_ts = 0;
|
||||
clog_checkpoint_scn.set_min();
|
||||
if (!is_valid()) {
|
||||
ret = OB_INVALID_ARGUMENT;
|
||||
LOG_WARN("batch update table store param is invalid", K(ret), KPC(this));
|
||||
@ -356,7 +356,7 @@ int ObBatchUpdateTableStoreParam::get_max_clog_checkpoint_ts(int64_t &clog_check
|
||||
} else if (!table->is_multi_version_minor_sstable()) {
|
||||
//do nothing
|
||||
} else {
|
||||
clog_checkpoint_ts = std::max(clog_checkpoint_ts, table->get_end_scn().get_val_for_tx());
|
||||
clog_checkpoint_scn = std::max(clog_checkpoint_scn, table->get_end_scn());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -340,7 +340,7 @@ struct ObBatchUpdateTableStoreParam final
|
||||
bool is_valid() const;
|
||||
void reset();
|
||||
int assign(const ObBatchUpdateTableStoreParam ¶m);
|
||||
int get_max_clog_checkpoint_ts(int64_t &clog_checkpoint_ts) const;
|
||||
int get_max_clog_checkpoint_scn(palf::SCN &clog_checkpoint_scn) const;
|
||||
|
||||
TO_STRING_KV(K_(tables_handle), K_(snapshot_version), K_(multi_version_start), K_(need_report),
|
||||
K_(rebuild_seq), K_(update_logical_minor_sstable), K_(start_scn), KP_(tablet_meta));
|
||||
|
||||
@ -225,9 +225,6 @@ int ObLockTable::gen_create_tablet_arg_(
|
||||
ObArray<ObTabletID> tablet_ids;
|
||||
ObArray<int64_t> tablet_schema_idxs;
|
||||
|
||||
// frozen_timestamp: next merge time
|
||||
int64_t frozen_timestamp = LS_INNER_TABLET_FROZEN_TIMESTAMP;
|
||||
|
||||
arg.reset();
|
||||
// create ObCreateTabletInfo
|
||||
if (OB_FAIL(tablet_ids.push_back(tablet_id))) {
|
||||
@ -242,10 +239,8 @@ int ObLockTable::gen_create_tablet_arg_(
|
||||
false/*is_create_bind_hidden_tablets*/))) {
|
||||
LOG_WARN("create tablet info init failed", K(ret), K(tablet_ids), K(tablet_id));
|
||||
// create ObBatchCreateTabletArg
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id,
|
||||
frozen_timestamp))) {
|
||||
LOG_WARN("ObBatchCreateTabletArg init create tablet failed", K(ret), K(tenant_id),
|
||||
K(ls_id), K(frozen_timestamp));
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id, palf::SCN::base_scn()))) {
|
||||
LOG_WARN("ObBatchCreateTabletArg init create tablet failed", K(ret), K(tenant_id), K(ls_id));
|
||||
} else if (OB_FAIL(arg.table_schemas_.push_back(table_schema))) {
|
||||
LOG_WARN("add table schema failed", K(ret), K(table_schema));
|
||||
} else if (OB_FAIL(arg.tablets_.push_back(create_tablet_info))) {
|
||||
|
||||
@ -1962,7 +1962,7 @@ int ObTabletCreateDeleteHelper::build_batch_create_tablet_arg(
|
||||
if (OB_FAIL(ret)) {
|
||||
} else {
|
||||
new_arg.id_ = old_arg.id_;
|
||||
new_arg.frozen_timestamp_ = old_arg.frozen_timestamp_;
|
||||
new_arg.major_frozen_scn_ = old_arg.major_frozen_scn_;
|
||||
|
||||
if (new_arg.get_tablet_count() > 0 && OB_FAIL(new_arg.table_schemas_.assign(old_arg.table_schemas_))) {
|
||||
LOG_WARN("failed to assign table schemas", K(ret), K(old_arg));
|
||||
@ -2249,7 +2249,6 @@ int ObTabletCreateDeleteHelper::do_create_tablet(
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
ObTenantMetaMemMgr *t3m = MTL(ObTenantMetaMemMgr*);
|
||||
SCN snapshot_version;
|
||||
const ObLSID &ls_id = arg.id_;
|
||||
const ObTabletMapKey key(ls_id, tablet_id);
|
||||
ObTablet *tablet = nullptr;
|
||||
@ -2265,9 +2264,7 @@ int ObTabletCreateDeleteHelper::do_create_tablet(
|
||||
ObMetaDiskAddr mem_addr;
|
||||
ObTabletTableStoreFlag table_store_flag;
|
||||
table_store_flag.set_with_major_sstable();
|
||||
if (OB_FAIL(snapshot_version.convert_tmp(arg.frozen_timestamp_))) {
|
||||
LOG_WARN("fail to convert scn", K(ret), K(arg.frozen_timestamp_));
|
||||
} else if (OB_FAIL(mem_addr.set_mem_addr(0, sizeof(ObTablet)))) {
|
||||
if (OB_FAIL(mem_addr.set_mem_addr(0, sizeof(ObTablet)))) {
|
||||
LOG_WARN("fail to set memory address", K(ret));
|
||||
} else if (OB_FAIL(acquire_tablet(key, tablet_handle, false/*only acquire*/))) {
|
||||
LOG_WARN("failed to acquire tablet", K(ret), K(key));
|
||||
@ -2276,9 +2273,9 @@ int ObTabletCreateDeleteHelper::do_create_tablet(
|
||||
} else if (!need_create_empty_major_sstable) {
|
||||
table_store_flag.set_without_major_sstable();
|
||||
LOG_INFO("no need to create sstable", K(ls_id), K(tablet_id), K(table_schema));
|
||||
} else if (OB_FAIL(build_create_sstable_param(table_schema, tablet_id, snapshot_version, param))) {
|
||||
} else if (OB_FAIL(build_create_sstable_param(table_schema, tablet_id, arg.major_frozen_scn_, param))) {
|
||||
LOG_WARN("failed to build create sstable param", K(ret), K(tablet_id),
|
||||
K(table_schema), K(snapshot_version), K(param));
|
||||
K(table_schema), K(arg), K(param));
|
||||
} else if (OB_FAIL(create_sstable(param, table_handle))) {
|
||||
LOG_WARN("failed to create sstable", K(ret), K(param));
|
||||
}
|
||||
@ -2288,10 +2285,10 @@ int ObTabletCreateDeleteHelper::do_create_tablet(
|
||||
ret = OB_ERR_UNEXPECTED;
|
||||
LOG_WARN("unexpected error, tablet is NULL", K(ret), K(tablet_handle));
|
||||
} else if (OB_FAIL(tablet->init(ls_id, tablet_id, data_tablet_id, lob_meta_tablet_id, lob_piece_tablet_id,
|
||||
create_scn, snapshot_version, table_schema, compat_mode, table_store_flag, table_handle, freezer))) {
|
||||
create_scn, arg.major_frozen_scn_, table_schema, compat_mode, table_store_flag, table_handle, freezer))) {
|
||||
LOG_WARN("failed to init tablet", K(ret), K(ls_id), K(tablet_id), K(data_tablet_id),
|
||||
K(lob_meta_tablet_id), K(lob_piece_tablet_id), K(index_tablet_array),
|
||||
K(snapshot_version), K(create_scn), K(table_schema), K(compat_mode), K(table_store_flag));
|
||||
K(arg), K(create_scn), K(table_schema), K(compat_mode), K(table_store_flag));
|
||||
} else if (OB_FAIL(t3m->compare_and_swap_tablet(key, mem_addr, tablet_handle, tablet_handle))) {
|
||||
LOG_WARN("failed to compare and swap tablet", K(ret), K(key), K(mem_addr), K(tablet_handle));
|
||||
} else {
|
||||
@ -2554,7 +2551,7 @@ int64_t ObSimpleBatchCreateTabletArg::to_string(char *buf, const int64_t buf_len
|
||||
J_NAME("ObSimpleBatchCreateTabletArg");
|
||||
J_COLON();
|
||||
J_KV("id", arg_.id_,
|
||||
"frozen_timestamp", arg_.frozen_timestamp_,
|
||||
"major_frozen_scn", arg_.major_frozen_scn_,
|
||||
"total_tablet_cnt", arg_.get_tablet_count());
|
||||
J_COMMA();
|
||||
|
||||
|
||||
@ -1037,6 +1037,9 @@ int ObTabletTableStore::need_remove_old_table(
|
||||
LOG_WARN("get invalid arguments", K(ret), K(multi_version_start));
|
||||
} else if (minor_tables_.empty() || INT64_MAX == minor_tables_[0]->get_upper_trans_version()) {
|
||||
// do nothing
|
||||
} else if (minor_tables_[0]->get_end_scn() > tablet_ptr_->get_tablet_meta().clog_checkpoint_scn_) {
|
||||
need_remove = false;
|
||||
//TODO(muwei.ym) remove it later
|
||||
} else if (minor_tables_[0]->get_upper_trans_version() <= major_tables_[0]->get_snapshot_version()) {
|
||||
// at least one minor sstable is coverd by major sstable
|
||||
// don't need to care about kept_multi_version_start here
|
||||
|
||||
@ -302,34 +302,35 @@ palf::SCN ObIDService::get_rec_scn()
|
||||
|
||||
int ObIDService::switch_to_follower_gracefully()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
const int64_t expire_time = ObTimeUtility::current_time() + 100000;
|
||||
int locked = false;
|
||||
if (OB_SUCC(rwlock_.wrlock(expire_time))) {
|
||||
locked = true;
|
||||
}
|
||||
while (is_logging_ && locked) {
|
||||
rwlock_.unlock();
|
||||
locked = false;
|
||||
ObClockGenerator::usleep(1000);
|
||||
if (ObTimeUtility::current_time() > expire_time) {
|
||||
break;
|
||||
}
|
||||
if (OB_SUCC(rwlock_.wrlock(expire_time))) {
|
||||
locked = true;
|
||||
}
|
||||
}
|
||||
if (locked) {
|
||||
const int64_t last_id = ATOMIC_LOAD(&last_id_);
|
||||
const int64_t limited_id = ATOMIC_LOAD(&limited_id_);
|
||||
// Caution: set limit id before submit log, make sure limit id <= last id
|
||||
ATOMIC_STORE(&limited_id_, last_id);
|
||||
//提交日志但不要求一定成功，防止阻塞卸任
|
||||
submit_log_(ATOMIC_LOAD(&last_id_), limited_id);
|
||||
rwlock_.unlock();
|
||||
locked = false;
|
||||
}
|
||||
TRANS_LOG(INFO, "switch to follower gracefully", K(ret), K(service_type_), K(locked));
|
||||
// int ret = OB_SUCCESS;
|
||||
// const int64_t expire_time = ObTimeUtility::current_time() + 100000;
|
||||
// int locked = false;
|
||||
// if (OB_SUCC(rwlock_.wrlock(expire_time))) {
|
||||
// locked = true;
|
||||
// }
|
||||
// while (is_logging_ && locked) {
|
||||
// rwlock_.unlock();
|
||||
// locked = false;
|
||||
// ObClockGenerator::usleep(1000);
|
||||
// if (ObTimeUtility::current_time() > expire_time) {
|
||||
// break;
|
||||
// }
|
||||
// if (OB_SUCC(rwlock_.wrlock(expire_time))) {
|
||||
// locked = true;
|
||||
// }
|
||||
// }
|
||||
// if (locked) {
|
||||
// const int64_t last_id = ATOMIC_LOAD(&last_id_);
|
||||
// const int64_t limited_id = ATOMIC_LOAD(&limited_id_);
|
||||
// // Caution: set limit id before submit log, make sure limit id <= last id
|
||||
// ATOMIC_STORE(&limited_id_, last_id);
|
||||
// //提交日志但不要求一定成功，防止阻塞卸任
|
||||
// submit_log_(ATOMIC_LOAD(&last_id_), limited_id);
|
||||
// rwlock_.unlock();
|
||||
// locked = false;
|
||||
// }
|
||||
// TRANS_LOG(INFO, "switch to follower gracefully", K(ret), K(service_type_), K(locked));
|
||||
TRANS_LOG(INFO, "switch to follower gracefully", K(last_id_), K(limited_id_), K(service_type_));
|
||||
// There is no failure scenario for ObIDService to switch the follower,
|
||||
// so return OB_SUCCESS directly.
|
||||
return OB_SUCCESS;
|
||||
|
||||
@ -358,6 +358,13 @@ int ObPartTransCtx::trans_kill_()
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
TRANS_LOG(INFO, "trans killed", K(trans_id_));
|
||||
|
||||
if (ctx_tx_data_.get_state() == ObTxData::RUNNING) {
|
||||
if (OB_FAIL(ctx_tx_data_.set_state(ObTxData::ABORT))) {
|
||||
TRANS_LOG(WARN, "set abort state in ctx_tx_data_ failed", K(ret));
|
||||
}
|
||||
}
|
||||
|
||||
mt_ctx_.trans_kill();
|
||||
return ret;
|
||||
}
|
||||
@ -1422,6 +1429,11 @@ int ObPartTransCtx::submit_redo_log(const bool is_freeze)
|
||||
ret = submit_log_impl_(ObTxLogType::TX_REDO_LOG);
|
||||
try_submit = true;
|
||||
}
|
||||
if (try_submit) {
|
||||
REC_TRANS_TRACE_EXT2(tlog_, submit_instant_log, Y(ret), OB_ID(arg2), is_freeze,
|
||||
OB_ID(used), ObTimeUtility::fast_current_time() - start,
|
||||
OB_ID(ctx_ref), get_ref());
|
||||
}
|
||||
} else if (OB_FAIL(lock_.try_lock())) {
|
||||
// try lock
|
||||
if (OB_EAGAIN == ret) {
|
||||
@ -1443,11 +1455,11 @@ int ObPartTransCtx::submit_redo_log(const bool is_freeze)
|
||||
try_submit = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (try_submit) {
|
||||
REC_TRANS_TRACE_EXT2(tlog_, submit_instant_log, Y(ret), OB_ID(arg2), is_freeze,
|
||||
OB_ID(used), ObTimeUtility::fast_current_time() - start,
|
||||
OB_ID(ctx_ref), get_ref());
|
||||
if (try_submit) {
|
||||
REC_TRANS_TRACE_EXT2(tlog_, submit_instant_log, Y(ret), OB_ID(arg2), is_freeze,
|
||||
OB_ID(used), ObTimeUtility::fast_current_time() - start,
|
||||
OB_ID(ctx_ref), get_ref());
|
||||
}
|
||||
}
|
||||
if (OB_BLOCK_FROZEN == ret) {
|
||||
ret = OB_SUCCESS;
|
||||
@ -5947,10 +5959,13 @@ int ObPartTransCtx::on_local_abort_tx_()
|
||||
|
||||
ObTxBufferNodeArray tmp_array;
|
||||
|
||||
start_us = ObTimeUtility::fast_current_time();
|
||||
if (OB_FAIL(mt_ctx_.trans_end(false, palf::SCN::invalid_scn(), ctx_tx_data_.get_end_log_ts()))) {
|
||||
if (!has_persisted_log_() && OB_FAIL(ctx_tx_data_.set_state(ObTxData::ABORT))) {
|
||||
TRANS_LOG(WARN, "set abort state failed", K(ret));
|
||||
} else if (OB_FALSE_IT(start_us = ObTimeUtility::fast_current_time())) {
|
||||
} else if (OB_FAIL(mt_ctx_.trans_end(false, palf::SCN::invalid_scn(), ctx_tx_data_.get_end_log_ts()))) {
|
||||
TRANS_LOG(WARN, "trans end error", KR(ret), K(commit_version), "context", *this);
|
||||
} else if (FALSE_IT(end_us = ObTimeUtility::fast_current_time())) {
|
||||
|
||||
} else if (OB_FAIL(trans_clear_())) {
|
||||
TRANS_LOG(WARN, "local tx clear error", KR(ret), K(*this));
|
||||
} else if (OB_FAIL(gen_total_mds_array_(tmp_array))) {
|
||||
@ -5975,7 +5990,6 @@ int ObPartTransCtx::on_local_abort_tx_()
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ObPartTransCtx::dump_2_text(FILE *fd)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
|
||||
@ -325,7 +325,6 @@ int ObTxTable::gen_create_tablet_arg_(
|
||||
ObArray<int64_t> tablet_schema_idxs;
|
||||
|
||||
// frozen_timestamp: next merge time
|
||||
int64_t frozen_timestamp = LS_INNER_TABLET_FROZEN_TIMESTAMP;
|
||||
|
||||
arg.reset();
|
||||
// create ObCreateTabletInfo
|
||||
@ -342,10 +341,8 @@ int ObTxTable::gen_create_tablet_arg_(
|
||||
false/*is_create_bind_hidden_tablets*/))) {
|
||||
LOG_WARN("create tablet info init failed", K(ret), K(tablet_ids), K(tablet_id));
|
||||
// create ObBatchCreateTabletArg
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id,
|
||||
frozen_timestamp))) {
|
||||
LOG_WARN("ObBatchCreateTabletArg init create tablet failed", K(ret), K(tenant_id),
|
||||
K(ls_id), K(frozen_timestamp));
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id, palf::SCN::base_scn()))) {
|
||||
LOG_WARN("ObBatchCreateTabletArg init create tablet failed", K(ret), K(tenant_id), K(ls_id));
|
||||
} else if (OB_FAIL(arg.table_schemas_.push_back(table_schema))) {
|
||||
LOG_WARN("add table schema failed", K(ret), K(table_schema));
|
||||
} else if (OB_FAIL(arg.tablets_.push_back(create_tablet_info))) {
|
||||
|
||||
@ -213,14 +213,6 @@ public:
|
||||
* be cleared.
|
||||
*/
|
||||
int get_recycle_scn(palf::SCN &recycle_scn);
|
||||
int get_recycle_ts(int64_t &recycle_ts)
|
||||
{
|
||||
int ret = OB_SUCCESS;
|
||||
palf::SCN recycle_scn = palf::SCN::min_scn();
|
||||
ret = get_recycle_scn(recycle_scn);
|
||||
recycle_ts = recycle_scn.get_val_for_lsn_allocator();
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the upper trans version for each given end_scn
|
||||
|
||||
@ -5,5 +5,4 @@ config:
|
||||
enable_metadb_used: 'false'
|
||||
enable_qa_mode: 'TRUE'
|
||||
location_expire_period: '1'
|
||||
__mirror_repository_section_name: taobao-test
|
||||
|
||||
|
||||
@ -78,7 +78,6 @@ int gen_create_tablet_arg(const int64_t tenant_id,
|
||||
obrpc::ObCreateTabletInfo tablet_info;
|
||||
ObArray<common::ObTabletID> index_tablet_ids;
|
||||
ObArray<int64_t> index_tablet_schema_idxs;
|
||||
int64_t frozen_timestamp = 0;
|
||||
uint64_t table_id = 12345;
|
||||
arg.reset();
|
||||
share::schema::ObTableSchema table_schema_obj;
|
||||
@ -110,10 +109,8 @@ int gen_create_tablet_arg(const int64_t tenant_id,
|
||||
false))) {
|
||||
STORAGE_LOG(WARN, "failed to init tablet info", KR(ret), K(index_tablet_ids),
|
||||
K(tablet_id), K(index_tablet_schema_idxs));
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id,
|
||||
frozen_timestamp))) {
|
||||
STORAGE_LOG(WARN, "failed to init create tablet", KR(ret), K(tenant_id), K(ls_id),
|
||||
K(frozen_timestamp));
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id, palf::SCN::min_scn()))) {
|
||||
STORAGE_LOG(WARN, "failed to init create tablet", KR(ret), K(tenant_id), K(ls_id));
|
||||
} else if (OB_FAIL(arg.table_schemas_.push_back(table_schema))) {
|
||||
STORAGE_LOG(WARN, "failed to push back table schema", KR(ret), K(table_schema));
|
||||
} else if (OB_FAIL(arg.tablets_.push_back(tablet_info))) {
|
||||
|
||||
@ -580,7 +580,6 @@ int TestDmlCommon::build_pure_data_tablet_arg(
|
||||
ObCreateTabletInfo tablet_info;
|
||||
ObArray<common::ObTabletID> tablet_id_array;
|
||||
ObArray<int64_t> tablet_schema_index_array;
|
||||
int64_t frozen_timestamp = 0;
|
||||
share::schema::ObTableSchema table_schema;
|
||||
build_data_table_schema(tenant_id, table_schema);
|
||||
|
||||
@ -592,9 +591,8 @@ int TestDmlCommon::build_pure_data_tablet_arg(
|
||||
} else if (OB_FAIL(tablet_info.init(tablet_id_array, data_tablet_id, tablet_schema_index_array, lib::Worker::CompatMode::MYSQL, false))) {
|
||||
STORAGE_LOG(WARN, "failed to init tablet info", K(ret), K(tablet_id_array),
|
||||
K(data_tablet_id), K(tablet_schema_index_array));
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id, frozen_timestamp))) {
|
||||
STORAGE_LOG(WARN, "failed to init create tablet", K(ret), K(tenant_id), K(ls_id),
|
||||
K(frozen_timestamp));
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id, palf::SCN::min_scn()))) {
|
||||
STORAGE_LOG(WARN, "failed to init create tablet", K(ret), K(tenant_id), K(ls_id));
|
||||
} else if (OB_FAIL(arg.table_schemas_.push_back(table_schema))) {
|
||||
STORAGE_LOG(WARN, "failed to push back table schema", K(ret), K(table_schema));
|
||||
} else if (OB_FAIL(arg.tablets_.push_back(tablet_info))) {
|
||||
@ -620,7 +618,6 @@ int TestDmlCommon::build_mixed_tablets_arg(
|
||||
ObCreateTabletInfo tablet_info;
|
||||
ObArray<common::ObTabletID> tablet_id_array;
|
||||
ObArray<int64_t> tablet_schema_index_array;
|
||||
int64_t frozen_timestamp = 0;
|
||||
share::schema::ObTableSchema data_table_schema;
|
||||
share::schema::ObTableSchema index_table_schema;
|
||||
build_data_table_schema(tenant_id, data_table_schema);
|
||||
@ -646,8 +643,8 @@ int TestDmlCommon::build_mixed_tablets_arg(
|
||||
} else if (OB_FAIL(tablet_info.init(tablet_id_array, data_tablet_id, tablet_schema_index_array, lib::Worker::CompatMode::MYSQL, false))) {
|
||||
STORAGE_LOG(WARN, "failed to init tablet info", K(ret), K(tablet_id_array),
|
||||
K(data_tablet_id), K(tablet_schema_index_array));
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id, frozen_timestamp))) {
|
||||
STORAGE_LOG(WARN, "failed to init create tablet", K(ret), K(tenant_id), K(ls_id), K(frozen_timestamp));
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id, palf::SCN::min_scn()))) {
|
||||
STORAGE_LOG(WARN, "failed to init create tablet", K(ret), K(tenant_id), K(ls_id));
|
||||
} else if (OB_FAIL(arg.table_schemas_.push_back(data_table_schema))) {
|
||||
STORAGE_LOG(WARN, "failed to push back data table schema", K(ret), K(data_table_schema));
|
||||
} else if (OB_FAIL(arg.table_schemas_.push_back(index_table_schema))) {
|
||||
|
||||
@ -308,7 +308,6 @@ int TestLobCommon::build_lob_tablet_arg(
|
||||
ObCreateTabletInfo tablet_info;
|
||||
ObArray<common::ObTabletID> tablet_id_array;
|
||||
ObArray<int64_t> tablet_schema_index_array;
|
||||
int64_t frozen_timestamp = 0;
|
||||
share::schema::ObTableSchema table_schema;
|
||||
build_data_table_schema(tenant_id, table_schema);
|
||||
share::schema::ObTableSchema lob_meta_schema;
|
||||
@ -333,8 +332,8 @@ int TestLobCommon::build_lob_tablet_arg(
|
||||
lib::get_compat_mode(), false/*is_create_bind_hidden_tablets*/))) {
|
||||
STORAGE_LOG(WARN, "failed to init tablet info", K(ret), K(tablet_id_array),
|
||||
K(data_tablet_id), K(tablet_schema_index_array));
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id, frozen_timestamp))) {
|
||||
STORAGE_LOG(WARN, "failed to init create tablet", K(ret), K(tenant_id), K(ls_id), K(frozen_timestamp));
|
||||
} else if (OB_FAIL(arg.init_create_tablet(ls_id, palf::SCN::min_scn()))) {
|
||||
STORAGE_LOG(WARN, "failed to init create tablet", K(ret), K(tenant_id), K(ls_id));
|
||||
} else if (OB_FAIL(arg.table_schemas_.push_back(table_schema))) {
|
||||
STORAGE_LOG(WARN, "failed to push back table schema", K(ret), K(table_schema));
|
||||
} else if (OB_FAIL(arg.table_schemas_.push_back(lob_meta_schema))) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user