hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
5f836a3c3b586747b34df9f9423f05affec7f3a9
oceanbase/src/share/ob_autoincrement_service.cpp

2337 lines
95 KiB
C++
Raw Blame History

/**
* Copyright (c) 2021 OceanBase
* OceanBase CE is licensed under Mulan PubL v2.
* You can use this software according to the terms and conditions of the Mulan PubL v2.
* You may obtain a copy of Mulan PubL v2 at:
* http://license.coscl.org.cn/MulanPubL-2.0
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PubL v2 for more details.
*/
#define USING_LOG_PREFIX SHARE
#include "share/ob_autoincrement_service.h"
#include <algorithm>
#include <stdint.h>
#include "lib/worker.h"
#include "lib/mysqlclient/ob_mysql_result.h"
#include "lib/string/ob_sql_string.h"
#include "lib/time/ob_time_utility.h"
#include "lib/mysqlclient/ob_mysql_transaction.h"
#include "lib/ash/ob_active_session_guard.h"
#include "share/inner_table/ob_inner_table_schema.h"
#include "share/partition_table/ob_partition_location.h"
#include "share/config/ob_server_config.h"
#include "share/schema/ob_table_schema.h"
#include "share/schema/ob_multi_version_schema_service.h"
#include "share/schema/ob_schema_getter_guard.h"
#include "share/schema/ob_schema_utils.h"
#include "share/ob_schema_status_proxy.h"
#include "observer/ob_server_struct.h"
#include "observer/ob_sql_client_decorator.h"
using namespace oceanbase::obrpc;
using namespace oceanbase::common;
using namespace oceanbase::common::hash;
using namespace oceanbase::common::sqlclient;
using namespace oceanbase::share;
using namespace oceanbase::share::schema;
namespace oceanbase
{
namespace share
{
#ifndef INT24_MIN
#define INT24_MIN (-8388607 - 1)
#endif
#ifndef INT24_MAX
#define INT24_MAX (8388607)
#endif
#ifndef UINT24_MAX
#define UINT24_MAX (16777215U)
#endif
static bool is_rpc_error(int error_code)
{
return (is_timeout_err(error_code) || is_server_down_error(error_code));
}
int CacheNode::combine_cache_node(CacheNode &new_node)
{
int ret = OB_SUCCESS;
if (new_node.cache_start_ > 0) {
if (cache_end_ < cache_start_
|| new_node.cache_end_ < new_node.cache_start_
|| cache_end_ > new_node.cache_start_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("cache node is invalid", K(*this), K(new_node), K(ret));
} else {
if (cache_end_ > 0 && cache_end_ == new_node.cache_start_ - 1) {
cache_end_ = new_node.cache_end_;
} else {
cache_start_ = new_node.cache_start_;
cache_end_ = new_node.cache_end_;
}
new_node.reset();
}
}
return ret;
}
int TableNode::alloc_handle(ObSmallAllocator &allocator,
const uint64_t offset,
const uint64_t increment,
const uint64_t desired_count,
const uint64_t max_value,
CacheHandle *&handle,
const bool is_retry_alloc)
{
int ret = OB_SUCCESS;
CacheNode node = curr_node_;
uint64_t min_value = 0;
const uint64_t local_sync = ATOMIC_LOAD(&local_sync_);
if (local_sync < next_value_) {
min_value = next_value_;
} else {
if (local_sync >= max_value) {
min_value = max_value;
} else {
min_value = local_sync + 1;
}
}
if (min_value < node.cache_start_) {
min_value = node.cache_start_;
}
uint64_t new_next_value = 0;
uint64_t needed_interval = 0;
if (curr_node_state_is_pending_) {
ret = OB_SIZE_OVERFLOW;
} else if (min_value >= max_value) {
new_next_value = max_value;
needed_interval = max_value;
} else if (min_value > node.cache_end_) {
ret = OB_SIZE_OVERFLOW;
LOG_TRACE("fail to alloc handle; cache is not enough", K(min_value), K(max_value), K(node), K(*this), K(ret));
} else {
ret = ObAutoincrementService::calc_next_value(min_value,
offset,
increment,
new_next_value);
if (OB_FAIL(ret)) {
LOG_WARN("fail to calc next value", K(ret));
} else {
bool reach_upper_limit = false;
if (max_value == node.cache_end_) {
// won't get cache from global again
reach_upper_limit = true;
}
if (new_next_value > node.cache_end_) {
if (reach_upper_limit) {
new_next_value = max_value;
needed_interval = max_value;
} else {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("fail to alloc handle; cache is not enough",
K(node), K(min_value), K(offset), K(increment), K(max_value), K(new_next_value),
K(*this), K(ret));
}
} else {
needed_interval = new_next_value + increment * (desired_count - 1);
// check overflow
if (needed_interval < new_next_value) {
needed_interval = UINT64_MAX;
}
if (needed_interval > node.cache_end_) {
if (reach_upper_limit) {
needed_interval = max_value;
} else {
ret = OB_SIZE_OVERFLOW;
// don't print warn log for common buffer burnout case, as we will fetch next buffer
if (is_retry_alloc) {
LOG_WARN("fail to alloc handle; cache is not enough", K(*this), K(ret));
}
}
}
}
}
}
if (OB_SUCC(ret)) {
handle = static_cast<CacheHandle *>(allocator.alloc());
if (NULL == handle) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to alloc cache handle", K(ret));
} else {
if (UINT64_MAX == needed_interval) {
// compatible with MySQL; return error when reach UINT64_MAX
ret = OB_ERR_REACH_AUTOINC_MAX;
LOG_WARN("reach UINT64_MAX", K(ret));
} else {
handle = new (handle) CacheHandle;
handle->offset_ = offset;
handle->increment_ = increment;
handle->next_value_ = new_next_value;
handle->prefetch_start_ = new_next_value;
handle->prefetch_end_ = needed_interval;
handle->max_value_ = max_value;
next_value_ = needed_interval + increment;
LOG_TRACE("succ to allocate cache handle", K(*handle), K(ret));
}
}
} else if (OB_SIZE_OVERFLOW == ret) {
if (prefetch_node_.cache_start_ > 0) {
if (OB_FAIL(curr_node_.combine_cache_node(prefetch_node_))) {
LOG_WARN("failed to combine cache node", K(ret));
} else if (OB_FAIL(alloc_handle(allocator, offset, increment, desired_count, max_value, handle))) {
LOG_WARN("failed to allocate cache handle", K(offset), K(increment), K(desired_count), K(ret));
}
}
} else {
LOG_WARN("unexpected error", K(ret));
}
return ret;
}
int TableNode::init(int64_t autoinc_table_part_num)
{
UNUSED(autoinc_table_part_num);
return OB_SUCCESS;
}
int CacheHandle::next_value(uint64_t &next_value)
{
int ret = OB_SUCCESS;
if (last_row_dup_flag_ && 0 != last_value_to_confirm_) {
// use last auto-increment value
next_value = last_value_to_confirm_;
last_row_dup_flag_ = false;
} else {
if (next_value_ >= max_value_) {
if (OB_FAIL(ObAutoincrementService::calc_prev_value(max_value_, offset_, increment_, next_value))) {
LOG_WARN("failed to calc previous value", K(ret));
}
} else {
if (next_value_ > prefetch_end_) {
ret = OB_ERR_UNEXPECTED;
LOG_DEBUG("no available value in CacheHandle", K_(next_value), K(ret));
} else {
next_value = next_value_;
// for insert...on duplicate key update
// if last row is duplicate, auto-increment value should be used in next row
last_value_to_confirm_ = next_value_;
last_row_dup_flag_ = false;
next_value_ += increment_;
}
}
}
return ret;
}
ObAutoincrementService::ObAutoincrementService()
: node_allocator_(),
handle_allocator_(),
mysql_proxy_(NULL),
srv_proxy_(NULL),
schema_service_(NULL),
map_mutex_(common::ObLatchIds::AUTO_INCREMENT_INIT_LOCK)
{
}
ObAutoincrementService::~ObAutoincrementService()
{
}
ObAutoincrementService &ObAutoincrementService::get_instance()
{
static ObAutoincrementService autoinc_service;
return autoinc_service;
}
int ObAutoincrementService::init(ObAddr &addr,
ObMySQLProxy *mysql_proxy,
ObSrvRpcProxy *srv_proxy,
ObMultiVersionSchemaService *schema_service,
rpc::frame::ObReqTransport *req_transport)
{
int ret = OB_SUCCESS;
my_addr_ = addr;
mysql_proxy_ = mysql_proxy;
srv_proxy_ = srv_proxy;
schema_service_ = schema_service;
ObMemAttr attr(OB_SERVER_TENANT_ID, ObModIds::OB_AUTOINCREMENT);
SET_USE_500(attr);
if (OB_FAIL(distributed_autoinc_service_.init(mysql_proxy))) {
LOG_WARN("fail init distributed_autoinc_service_ service", K(ret));
} else if (OB_FAIL(global_autoinc_service_.init(my_addr_, req_transport))) {
LOG_WARN("fail init auto inc global service", K(ret));
} else if (OB_FAIL(node_allocator_.init(sizeof(TableNode), attr))) {
LOG_WARN("failed to init table node allocator", K(ret));
} else if (OB_FAIL(handle_allocator_.init(sizeof(CacheHandle), attr))) {
LOG_WARN("failed to init cache handle allocator", K(ret));
} else if (OB_FAIL(node_map_.init(attr))) {
LOG_WARN("failed to init table node map", K(ret));
} else {
for (int64_t i = 0; i < INIT_NODE_MUTEX_NUM; ++i) {
init_node_mutex_[i].set_latch_id(common::ObLatchIds::AUTO_INCREMENT_INIT_LOCK);
}
}
return ret;
}
//only used for logic backup
int ObAutoincrementService::init_for_backup(ObAddr &addr,
ObMySQLProxy *mysql_proxy,
ObSrvRpcProxy *srv_proxy,
ObMultiVersionSchemaService *schema_service,
rpc::frame::ObReqTransport *req_transport)
{
int ret = OB_SUCCESS;
my_addr_ = addr;
mysql_proxy_ = mysql_proxy;
srv_proxy_ = srv_proxy;
schema_service_ = schema_service;
OZ(distributed_autoinc_service_.init(mysql_proxy));
OZ(global_autoinc_service_.init(my_addr_, req_transport));
return ret;
}
int ObAutoincrementService::get_handle(AutoincParam &param,
CacheHandle *&handle)
{
ACTIVE_SESSION_FLAG_SETTER_GUARD(in_sequence_load);
int ret = param.autoinc_mode_is_order_ ?
get_handle_order(param, handle) : get_handle_noorder(param, handle);
return ret;
}
int ObAutoincrementService::get_handle_order(AutoincParam &param, CacheHandle *&handle)
{
int ret = OB_SUCCESS;
const uint64_t tenant_id = param.tenant_id_;
const uint64_t table_id = param.autoinc_table_id_;
const uint64_t column_id = param.autoinc_col_id_;
const ObObjType column_type = param.autoinc_col_type_;
const uint64_t offset = param.autoinc_offset_;
const uint64_t increment = param.autoinc_increment_;
const uint64_t max_value = get_max_value(column_type);
const int64_t auto_increment_cache_size = param.auto_increment_cache_size_;
const int64_t autoinc_version = param.autoinc_version_;
uint64_t desired_count = 0;
// calc nb_desired_values in MySQL
if (0 == param.autoinc_intervals_count_) {
desired_count = param.total_value_count_;
} else if (param.autoinc_intervals_count_ <= AUTO_INC_DEFAULT_NB_MAX_BITS) {
desired_count = AUTO_INC_DEFAULT_NB_ROWS * (1 << param.autoinc_intervals_count_);
if (desired_count > AUTO_INC_DEFAULT_NB_MAX) {
desired_count = AUTO_INC_DEFAULT_NB_MAX;
}
} else {
desired_count = AUTO_INC_DEFAULT_NB_MAX;
}
// allocate auto-increment value first time
if (0 == param.autoinc_desired_count_) {
param.autoinc_desired_count_ = desired_count;
}
desired_count = param.autoinc_desired_count_;
const uint64_t batch_count = increment * desired_count;
AutoincKey key(tenant_id, table_id, column_id);
uint64_t table_auto_increment = param.autoinc_auto_increment_;
uint64_t start_inclusive = 0;
uint64_t end_inclusive = 0;
uint64_t sync_value = 0;
if (OB_UNLIKELY(table_auto_increment > max_value)) {
ret = OB_ERR_REACH_AUTOINC_MAX;
LOG_WARN("reach max autoinc", K(ret), K(table_auto_increment));
} else if (OB_FAIL(global_autoinc_service_.get_value(key, offset, increment, max_value,
table_auto_increment, batch_count,
auto_increment_cache_size, autoinc_version,
sync_value, start_inclusive, end_inclusive))) {
LOG_WARN("fail get value", K(ret));
} else if (OB_UNLIKELY(sync_value > max_value || start_inclusive > max_value)) {
ret = OB_ERR_REACH_AUTOINC_MAX;
LOG_WARN("reach max autoinc", K(start_inclusive), K(max_value), K(ret));
} else {
uint64_t new_next_value = 0;
uint64_t needed_interval = 0;
if (start_inclusive >= max_value) {
new_next_value = max_value;
needed_interval = max_value;
} else if (OB_FAIL(calc_next_value(start_inclusive, offset, increment, new_next_value))) {
LOG_WARN("fail to calc next value", K(ret));
} else if (OB_UNLIKELY(new_next_value > end_inclusive)) {
if (max_value == end_inclusive) {
new_next_value = max_value;
needed_interval = max_value;
} else {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("fail to alloc handle; cache is not enough",
K(start_inclusive), K(end_inclusive), K(offset), K(increment), K(max_value),
K(new_next_value), K(ret));
}
} else {
needed_interval = new_next_value + increment * (desired_count - 1);
// check overflow
if (needed_interval < new_next_value) {
needed_interval = UINT64_MAX;
}
if (needed_interval > end_inclusive) {
if (max_value == end_inclusive) {
needed_interval = max_value;
} else {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("fail to alloc handle; cache is not enough", K(ret));
}
}
}
if (OB_SUCC(ret)) {
if (OB_UNLIKELY(UINT64_MAX == needed_interval)) {
// compatible with MySQL; return error when reach UINT64_MAX
ret = OB_ERR_REACH_AUTOINC_MAX;
LOG_WARN("reach UINT64_MAX", K(ret));
} else if (OB_ISNULL(handle = static_cast<CacheHandle *>(handle_allocator_.alloc()))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_ERROR("failed to alloc cache handle", K(ret));
} else {
handle = new (handle) CacheHandle;
handle->offset_ = offset;
handle->increment_ = increment;
handle->next_value_ = new_next_value;
handle->prefetch_start_ = new_next_value;
handle->prefetch_end_ = needed_interval;
handle->max_value_ = max_value;
LOG_TRACE("succ to allocate cache handle", K(*handle), K(ret));
}
}
}
return ret;
}
int ObAutoincrementService::get_handle_noorder(AutoincParam &param, CacheHandle *&handle)
{
int ret = OB_SUCCESS;
const uint64_t tenant_id = param.tenant_id_;
const uint64_t table_id = param.autoinc_table_id_;
const uint64_t column_id = param.autoinc_col_id_;
const ObObjType column_type = param.autoinc_col_type_;
const uint64_t offset = param.autoinc_offset_;
const uint64_t increment = param.autoinc_increment_;
const uint64_t max_value = get_max_value(column_type);
uint64_t desired_count = 0;
// calc nb_desired_values in MySQL
if (0 == param.autoinc_intervals_count_) {
desired_count = param.total_value_count_;
} else if (param.autoinc_intervals_count_ <= AUTO_INC_DEFAULT_NB_MAX_BITS) {
desired_count = AUTO_INC_DEFAULT_NB_ROWS * (1 << param.autoinc_intervals_count_);
if (desired_count > AUTO_INC_DEFAULT_NB_MAX) {
desired_count = AUTO_INC_DEFAULT_NB_MAX;
}
} else {
desired_count = AUTO_INC_DEFAULT_NB_MAX;
}
// allocate auto-increment value first time
if (0 == param.autoinc_desired_count_) {
param.autoinc_desired_count_ = desired_count;
}
desired_count = param.autoinc_desired_count_;
TableNode *table_node = NULL;
LOG_DEBUG("begin to get cache handle", K(param));
if (OB_FAIL(get_table_node(param, table_node))) {
LOG_WARN("failed to get table node", K(param), K(ret));
}
if (OB_SUCC(ret)) {
int ignore_ret = try_periodic_refresh_global_sync_value(tenant_id,
table_id,
column_id,
*table_node);
if (OB_SUCCESS != ignore_ret) {
LOG_INFO("fail refresh global sync value. ignore this failure.", K(ignore_ret));
}
}
// alloc handle
bool need_prefetch = false;
if (OB_SUCC(ret)) {
if (OB_FAIL(alloc_autoinc_try_lock(table_node->alloc_mutex_))) {
LOG_WARN("failed to get alloc lock", K(param), K(*table_node), K(ret));
} else {
if (OB_SIZE_OVERFLOW == (ret = table_node->alloc_handle(handle_allocator_,
offset,
increment,
desired_count,
max_value,
handle))) {
TableNode mock_node;
if (param.autoinc_desired_count_ <= 0) {
// do nothing
} else if (OB_FAIL(fetch_table_node(param, &mock_node))) {
LOG_WARN("failed to fetch table node", K(param), K(ret));
} else {
LOG_TRACE("fetch table node success", K(param), K(mock_node), K(*table_node));
atomic_update(table_node->local_sync_, mock_node.local_sync_);
atomic_update(table_node->last_refresh_ts_, mock_node.last_refresh_ts_);
table_node->prefetch_node_.reset();
if (mock_node.curr_node_.cache_start_ == table_node->curr_node_.cache_end_ + 1) {
// when the above condition is true, it means that no other thread has consume
// any cache. intra-partition ascending property can be kept
table_node->curr_node_.cache_end_ = mock_node.curr_node_.cache_end_;
} else {
table_node->curr_node_.cache_start_ = mock_node.curr_node_.cache_start_;
table_node->curr_node_.cache_end_ = mock_node.curr_node_.cache_end_;
}
table_node->curr_node_state_is_pending_ = false;
// in order mode, we always trust the next_value returned by global service,
// because the local next_value may be calculated with the previous increment params.
// and the increment_increment and increment_offset may be changed.
if (param.autoinc_mode_is_order_) {
table_node->next_value_ = mock_node.next_value_;
}
if (OB_FAIL(table_node->alloc_handle(handle_allocator_,
offset, increment,
desired_count, max_value, handle))) {
LOG_WARN("failed to alloc cache handle", K(param), K(ret));
} else {
LOG_DEBUG("succ to get cache handle", K(param), K(*handle), K(ret));
}
}
}
table_node->alloc_mutex_.unlock();
}
if (OB_SUCC(ret) && table_node->prefetch_condition() && !table_node->prefetching_) {
need_prefetch = true;
table_node->prefetching_ = true;
}
if (OB_SUCC(ret) && OB_UNLIKELY(need_prefetch)) {
LOG_DEBUG("begin to prefetch table node", K(param), K(ret));
// ensure single thread to prefetch
TableNode mock_node;
if (OB_FAIL(fetch_table_node(param, &mock_node, true))) {
LOG_WARN("failed to fetch table node", K(param), K(ret));
} else if (OB_FAIL(alloc_autoinc_try_lock(table_node->alloc_mutex_))) {
LOG_WARN("failed to get alloc mutex lock", K(ret));
} else {
LOG_INFO("fetch table node success", K(param), K(mock_node), K(*table_node));
if (table_node->prefetch_node_.cache_start_ != 0 ||
mock_node.prefetch_node_.cache_start_ <= table_node->curr_node_.cache_end_) {
LOG_TRACE("new table_node has been fetched by other, ignore");
} else {
atomic_update(table_node->local_sync_, mock_node.local_sync_);
atomic_update(table_node->last_refresh_ts_, mock_node.last_refresh_ts_);
table_node->prefetch_node_.cache_start_ = mock_node.prefetch_node_.cache_start_;
table_node->prefetch_node_.cache_end_ = mock_node.prefetch_node_.cache_end_;
}
table_node->prefetching_ = false;
table_node->alloc_mutex_.unlock();
}
}
}
// table node must be reverted after get to decrement reference count
if (OB_UNLIKELY(NULL != table_node)) {
node_map_.revert(table_node);
}
return ret;
}
int ObAutoincrementService::try_periodic_refresh_global_sync_value(
uint64_t tenant_id,
uint64_t table_id,
uint64_t column_id,
TableNode &table_node)
{
int ret = OB_SUCCESS;
const int64_t cur_time = ObTimeUtility::current_time();
const int64_t cache_refresh_interval = GCONF.autoinc_cache_refresh_interval;
int64_t delta = cur_time - ATOMIC_LOAD(&table_node.last_refresh_ts_);
if (OB_LIKELY(delta * PRE_OP_THRESHOLD < cache_refresh_interval)) {
// do nothing
} else if (delta < cache_refresh_interval) {
// try to sync
if (OB_FAIL(table_node.sync_mutex_.trylock())) {
// other thread is doing sync; pass through
ret = OB_SUCCESS;
} else {
delta = cur_time - ATOMIC_LOAD(&table_node.last_refresh_ts_);
if (delta * PRE_OP_THRESHOLD < cache_refresh_interval) {
// do nothing; refreshed already
} else if (OB_FAIL(fetch_global_sync(tenant_id, table_id, column_id, table_node, true))) {
LOG_WARN("failed to get global sync", K(table_node), K(ret));
}
table_node.sync_mutex_.unlock();
}
} else {
// must sync
if (OB_FAIL(table_node.sync_mutex_.lock())) {
LOG_WARN("failed to get sync lock", K(table_node), K(ret));
} else {
delta = cur_time - ATOMIC_LOAD(&table_node.last_refresh_ts_);
if (delta * PRE_OP_THRESHOLD < cache_refresh_interval) {
// do nothing; refreshed already
} else if (OB_FAIL(fetch_global_sync(tenant_id, table_id, column_id, table_node))) {
LOG_WARN("failed to get global sync", K(table_node), K(ret));
}
table_node.sync_mutex_.unlock();
}
}
return ret;
}
void ObAutoincrementService::release_handle(CacheHandle *&handle)
{
handle_allocator_.free(handle);
// bug#8200783, should reset handle here
handle = NULL;
}
int ObAutoincrementService::refresh_sync_value(const obrpc::ObAutoincSyncArg &arg)
{
int ret = OB_SUCCESS;
LOG_DEBUG("begin to get global sync", K(arg));
TableNode *table_node = NULL;
AutoincKey key;
key.tenant_id_ = arg.tenant_id_;
key.table_id_ = arg.table_id_;
key.column_id_ = arg.column_id_;
if (OB_ENTRY_NOT_EXIST == (ret = node_map_.get(key, table_node))) {
LOG_TRACE("there is no cache here", K(arg));
ret = OB_SUCCESS;
} else if (OB_SUCC(ret)) {
const uint64_t sync_value = arg.sync_value_;
lib::ObMutexGuard guard(table_node->sync_mutex_);
atomic_update(table_node->local_sync_, sync_value);
atomic_update(table_node->last_refresh_ts_, ObTimeUtility::current_time());
} else {
LOG_WARN("failed to do get table node", K(ret));
}
// table node must be reverted after get to decrement reference count
if (NULL != table_node) {
node_map_.revert(table_node);
}
return ret;
}
int ObAutoincrementService::lock_autoinc_row(const uint64_t &tenant_id,
const uint64_t &table_id,
const uint64_t &column_id,
common::ObMySQLTransaction &trans)
{
int ret = OB_SUCCESS;
ObSqlString lock_sql;
SMART_VAR(ObMySQLProxy::MySQLResult, res) {
ObMySQLResult *result = NULL;
ObISQLClient *sql_client = &trans;
if (OB_FAIL(lock_sql.assign_fmt("SELECT sequence_key, sequence_value, sync_value "
"FROM %s WHERE tenant_id = %lu AND sequence_key = %lu "
"AND column_id = %lu FOR UPDATE",
OB_ALL_AUTO_INCREMENT_TNAME,
ObSchemaUtils::get_extract_tenant_id(tenant_id, tenant_id),
ObSchemaUtils::get_extract_schema_id(tenant_id, table_id),
column_id))) {
LOG_WARN("failed to assign sql", KR(ret));
} else if (OB_FAIL(trans.read(res, tenant_id, lock_sql.ptr()))) {
LOG_WARN("failded to execute sql", KR(ret), K(lock_sql));
} else if (OB_ISNULL(result = res.get_result())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to get result, result is NULL", KR(ret));
} else if (OB_FAIL(result->next())) {
if (OB_ITER_END == ret) {
LOG_WARN("autoincrement not exist", KR(ret), K(lock_sql));
} else {
LOG_WARN("iterate next result fail", KR(ret), K(lock_sql));
}
}
}
return ret;
}
//This implement is only for Truncate, table need to reset autoinc version after truncate
int ObAutoincrementService::reset_autoinc_row(const uint64_t &tenant_id,
const uint64_t &table_id,
const uint64_t &column_id,
const int64_t &autoinc_version,
common::ObMySQLTransaction &trans)
{
int ret = OB_SUCCESS;
ObSqlString update_sql;
int64_t affected_rows = 0;
if (OB_FAIL(update_sql.assign_fmt("UPDATE %s SET sequence_value = 1, sync_value = 0, truncate_version = %ld",
OB_ALL_AUTO_INCREMENT_TNAME,
autoinc_version))) {
LOG_WARN("failed to assign sql", KR(ret));
} else if (OB_FAIL(update_sql.append_fmt(" WHERE sequence_key = %lu AND tenant_id = %lu AND column_id = %lu",
ObSchemaUtils::get_extract_schema_id(tenant_id, table_id),
ObSchemaUtils::get_extract_tenant_id(tenant_id, tenant_id),
column_id))) {
LOG_WARN("failed to append sql", KR(ret));
} else if (OB_FAIL(trans.write(tenant_id, update_sql.ptr(), affected_rows))) {
LOG_WARN("failed to update __all_auto_increment", KR(ret), K(update_sql));
} else if (OB_UNLIKELY(affected_rows > 1)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected affected rows", KR(ret), K(table_id), K(affected_rows), K(update_sql));
}
return ret;
}
// for new truncate table
int ObAutoincrementService::reinit_autoinc_row(const uint64_t &tenant_id,
const uint64_t &table_id,
const uint64_t &column_id,
const int64_t &autoinc_version,
common::ObMySQLTransaction &trans)
{
int ret = OB_SUCCESS;
if (OB_FAIL(lock_autoinc_row(tenant_id, table_id, column_id, trans))) {
LOG_WARN("failed to select for update", KR(ret));
} else if (OB_FAIL(reset_autoinc_row(tenant_id, table_id, column_id, autoinc_version, trans))) {
LOG_WARN("failed to update auto increment", KR(ret));
}
return ret;
}
// use for alter table add autoincrement
int ObAutoincrementService::try_lock_autoinc_row(const uint64_t &tenant_id,
const uint64_t &table_id,
const uint64_t &column_id,
const int64_t &autoinc_version,
bool &need_update_inner_table,
common::ObMySQLTransaction &trans)
{
int ret = OB_SUCCESS;
ObSqlString lock_sql;
need_update_inner_table = false;
SMART_VAR(ObMySQLProxy::MySQLResult, res) {
ObMySQLResult *result = NULL;
if (OB_UNLIKELY(OB_INVALID_TENANT_ID == tenant_id
|| OB_INVALID_ID == table_id
|| 0 == column_id)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("arg is not invalid", KR(ret), K(tenant_id), K(table_id), K(column_id));
} else if (OB_FAIL(lock_sql.assign_fmt("SELECT truncate_version "
"FROM %s WHERE tenant_id = %lu AND sequence_key = %lu "
"AND column_id = %lu FOR UPDATE",
OB_ALL_AUTO_INCREMENT_TNAME,
ObSchemaUtils::get_extract_tenant_id(tenant_id, tenant_id),
ObSchemaUtils::get_extract_schema_id(tenant_id, table_id),
column_id))) {
LOG_WARN("failed to assign sql", KR(ret));
} else if (OB_FAIL(trans.read(res, tenant_id, lock_sql.ptr()))) {
LOG_WARN("failded to execute sql", KR(ret), K(lock_sql));
} else if (OB_ISNULL(result = res.get_result())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("failed to get result, result is NULL", KR(ret));
} else if (OB_FAIL(result->next())) {
if (OB_ITER_END == ret) {
ret = OB_SUCCESS;
LOG_INFO("autoinc row not exist", K(tenant_id), K(table_id), K(column_id));
} else {
LOG_WARN("iterate next result fail", KR(ret), K(lock_sql));
}
} else {
int64_t inner_autoinc_version = OB_INVALID_VERSION;
if (OB_FAIL(result->get_int(0l, inner_autoinc_version))) {
LOG_WARN("fail to get truncate_version", KR(ret));
} else if (inner_autoinc_version > autoinc_version) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("autoincrement's newest version can not less than inner version",
KR(ret), K(tenant_id), K(table_id), K(column_id),
K(inner_autoinc_version), K(autoinc_version));
} else if (inner_autoinc_version < autoinc_version) {
need_update_inner_table = true;
LOG_INFO("inner autoinc version is old, we need to update inner table",
K(tenant_id), K(table_id), K(column_id), K(inner_autoinc_version), K(autoinc_version));
} else {
LOG_TRACE("inner autoinc version is equal, not need to update inner table",
K(tenant_id), K(table_id), K(column_id));
}
}
}
return ret;
}
int ObAutoincrementService::clear_autoinc_cache_all(const uint64_t tenant_id,
const uint64_t table_id,
const uint64_t column_id,
const bool autoinc_is_order)
{
int ret = OB_SUCCESS;
if (OB_SUCC(ret)) {
// sync observer where table partitions exist
LOG_INFO("begin to clear all sever's auto-increment cache",
K(tenant_id), K(table_id), K(column_id), K(autoinc_is_order));
ObAutoincSyncArg arg;
arg.tenant_id_ = tenant_id;
arg.table_id_ = table_id;
arg.column_id_ = column_id;
ObHashSet<ObAddr> server_set;
if (OB_FAIL(server_set.create(PARTITION_LOCATION_SET_BUCKET_NUM))) {
LOG_WARN("failed to create hash set", K(ret));
} else if (OB_FAIL(get_server_set(tenant_id, table_id, server_set, true))) {
SHARE_LOG(WARN, "failed to get table partitions server set", K(ret));
}
if (OB_SUCC(ret)) {
const int64_t sync_timeout = SYNC_OP_TIMEOUT + TIME_SKEW;
ObHashSet<ObAddr>::iterator iter;
for(iter = server_set.begin(); OB_SUCC(ret) && iter != server_set.end(); ++iter) {
LOG_INFO("send rpc call to other observers", "server", iter->first, K(tenant_id), K(table_id));
if (OB_FAIL(srv_proxy_->to(iter->first)
.by(tenant_id)
.timeout(sync_timeout)
.clear_autoinc_cache(arg))) {
if (is_rpc_error(ret) || autoinc_is_order) {
// ignore time out and clear ordered auto increment cache error, go on
LOG_WARN("rpc call time out, ignore the error", "server", iter->first,
K(tenant_id), K(table_id), K(autoinc_is_order), K(ret));
ret = OB_SUCCESS;
} else {
LOG_WARN("failed to send rpc call", K(tenant_id), K(table_id), K(ret));
}
}
}
}
}
return ret;
}
int ObAutoincrementService::clear_autoinc_cache(const obrpc::ObAutoincSyncArg &arg)
{
int ret = OB_SUCCESS;
LOG_INFO("begin to clear local auto-increment cache", K(arg));
// auto-increment key
AutoincKey key;
key.tenant_id_ = arg.tenant_id_;
key.table_id_ = arg.table_id_;
key.column_id_ = arg.column_id_;
map_mutex_.lock();
if (OB_FAIL(node_map_.del(key))) {
LOG_WARN("failed to erase table node", K(arg), K(ret));
}
map_mutex_.unlock();
if (OB_ENTRY_NOT_EXIST == ret) {
// do nothing; key does not exist
ret = OB_SUCCESS;
}
if (OB_SUCC(ret) && OB_FAIL(global_autoinc_service_.clear_global_autoinc_cache(key))) {
LOG_WARN("failed to clear global autoinc cache", K(ret));
}
return ret;
}
uint64_t ObAutoincrementService::get_max_value(const common::ObObjType type)
{
static const uint64_t type_max_value[] =
{
// null
0,
// signed
INT8_MAX, // tiny int 127
INT16_MAX, // short 32767
INT24_MAX, // medium int 8388607
INT32_MAX, // int 2147483647
INT64_MAX, // bigint 9223372036854775807
// unsigned
UINT8_MAX, // 255
UINT16_MAX, // 65535
UINT24_MAX, // 16777215
UINT32_MAX, // 4294967295
UINT64_MAX, // 18446744073709551615
// float
0x1000000ULL, // float /* We use the maximum as per IEEE754-2008 standard, 2^24; compatible with MySQL */
0x20000000000000ULL, // double /* We use the maximum as per IEEE754-2008 standard, 2^53; compatible with MySQL */
0x1000000ULL, // ufloat
0x20000000000000ULL, // udouble
// do not support
// "NUMBER",
// "NUMBER UNSIGNED",
//
// "DATETIME",
// "TIMESTAMP",
// "DATE",
// "TIME",
// "YEAR",
//
// "VARCHAR",
// "CHAR",
// "VARBINARY",
// "BINARY",
//
// "EXT",
// "UNKNOWN",
0
};
return type_max_value[OB_LIKELY(type < ObNumberType) ? type : ObNumberType];
}
int ObAutoincrementService::get_table_node(const AutoincParam &param, TableNode *&table_node)
{
int ret = OB_SUCCESS;
uint64_t tenant_id = param.tenant_id_;
uint64_t table_id = param.autoinc_table_id_;
uint64_t column_id = param.autoinc_col_id_;
// auto-increment key
AutoincKey key;
key.tenant_id_ = tenant_id;
key.table_id_ = table_id;
key.column_id_ = column_id;
int64_t autoinc_version = get_modify_autoinc_version(param.autoinc_version_);
if (OB_FAIL(node_map_.get(key, table_node))) {
if (ret != OB_ENTRY_NOT_EXIST) {
LOG_ERROR("get from map failed", K(ret));
} else {
lib::ObMutex &mutex = init_node_mutex_[table_id % INIT_NODE_MUTEX_NUM];
if (OB_FAIL(mutex.lock())) {
LOG_WARN("failed to get lock", K(ret));
} else {
if (OB_ENTRY_NOT_EXIST == (ret = node_map_.get(key, table_node))) {
LOG_INFO("alloc table node for auto increment key", K(key));
if (OB_FAIL(node_map_.alloc_value(table_node))) {
LOG_ERROR("failed to alloc table node", K(param), K(ret));
} else if (OB_FAIL(table_node->init(param.autoinc_table_part_num_))) {
LOG_ERROR("failed to init table node", K(param), K(ret));
} else {
table_node->prefetch_node_.reset();
table_node->autoinc_version_ = autoinc_version;
lib::ObMutexGuard guard(map_mutex_);
if (OB_FAIL(node_map_.insert_and_get(key, table_node))) {
LOG_WARN("failed to create table node", K(param), K(ret));
}
}
if (OB_FAIL(ret) && table_node != nullptr) {
node_map_.free_value(table_node);
table_node = NULL;
}
}
mutex.unlock();
}
}
} else {
if (OB_FAIL(alloc_autoinc_try_lock(table_node->alloc_mutex_))) {
LOG_WARN("failed to get lock", K(ret));
} else {
// local cache is expired
if (OB_UNLIKELY(autoinc_version > table_node->autoinc_version_)) {
LOG_INFO("start to reset table node", K(*table_node), K(param));
table_node->next_value_ = 0;
table_node->local_sync_ = 0;
table_node->curr_node_.reset();
table_node->prefetch_node_.reset();
table_node->prefetching_ = false;
table_node->curr_node_state_is_pending_ = true;
table_node->autoinc_version_ = autoinc_version;
// old request cannot get table node, it should retry
} else if (OB_UNLIKELY(autoinc_version < table_node->autoinc_version_)) {
ret = OB_AUTOINC_CACHE_NOT_EQUAL;
LOG_WARN("old reqeust can not get table node, it should retry", KR(ret), K(autoinc_version), K(table_node->autoinc_version_));
}
table_node->alloc_mutex_.unlock();
}
}
if (OB_SUCC(ret)) {
LOG_DEBUG("succ to get table node", K(param), KPC(table_node), K(ret));
} else {
LOG_WARN("failed to get table node", K(param), K(ret));
}
return ret;
}
int ObAutoincrementService::alloc_autoinc_try_lock(lib::ObMutex &alloc_mutex)
{
int ret = OB_SUCCESS;
static const int64_t SLEEP_TS_US = 10;
while (OB_SUCC(ret) && OB_FAIL(alloc_mutex.trylock())) {
if (OB_EAGAIN == ret) {
THIS_WORKER.check_wait();
ob_usleep(SLEEP_TS_US);
if (OB_FAIL(THIS_WORKER.check_status())) { // override ret code
LOG_WARN("fail to check worker status", K(ret));
}
} else {
LOG_WARN("fail to try lock mutex", K(ret));
}
}
return ret;
}
int ObAutoincrementService::fetch_table_node(const AutoincParam &param,
TableNode *table_node,
const bool fetch_prefetch)
{
int ret = OB_SUCCESS;
const uint64_t tenant_id = param.tenant_id_;
const uint64_t table_id = param.autoinc_table_id_;
const uint64_t column_id = param.autoinc_col_id_;
const ObObjType column_type = param.autoinc_col_type_;
const uint64_t part_num = param.autoinc_table_part_num_;
const uint64_t desired_count = param.autoinc_desired_count_;
const uint64_t offset = param.autoinc_offset_;
const uint64_t increment = param.autoinc_increment_;
const int64_t autoinc_version = param.autoinc_version_;
if (part_num <= 0 || ObNullType == column_type) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(part_num), K(column_type), K(ret));
} else {
uint64_t sync_value = 0;
uint64_t max_value = get_max_value(column_type);
int64_t auto_increment_cache_size = param.auto_increment_cache_size_;
uint64_t start_inclusive = 0;
uint64_t end_inclusive = 0;
if (auto_increment_cache_size < 1 || auto_increment_cache_size > MAX_INCREMENT_CACHE_SIZE) {
// no ret, just log error
LOG_ERROR("unexpected auto_increment_cache_size", K(auto_increment_cache_size));
auto_increment_cache_size = DEFAULT_INCREMENT_CACHE_SIZE;
}
// For ORDER mode, the local cache_size is always 1, and the central(remote) cache_size
// is the configuration value.
const uint64_t local_cache_size = auto_increment_cache_size;
uint64_t prefetch_count = std::min(max_value / 100 / part_num, local_cache_size);
uint64_t batch_count = 0;
if (prefetch_count > 1) {
batch_count = std::max(increment * prefetch_count, increment * desired_count);
} else {
batch_count = increment * desired_count;
}
AutoincKey key(tenant_id, table_id, column_id);
uint64_t table_auto_increment = param.autoinc_auto_increment_;
if (OB_UNLIKELY(table_auto_increment > max_value)) {
ret = OB_ERR_REACH_AUTOINC_MAX;
LOG_WARN("reach max autoinc", K(ret), K(table_auto_increment));
} else if (OB_FAIL(distributed_autoinc_service_.get_value(
key, offset, increment, max_value, table_auto_increment,
batch_count, auto_increment_cache_size, autoinc_version, sync_value,
start_inclusive, end_inclusive))) {
LOG_WARN("fail get value", K(ret));
} else if (sync_value > max_value || start_inclusive > max_value) {
ret = OB_ERR_REACH_AUTOINC_MAX;
LOG_WARN("reach max autoinc", K(start_inclusive), K(max_value), K(ret));
}
if (OB_SUCC(ret)) {
atomic_update(table_node->local_sync_, sync_value);
atomic_update(table_node->last_refresh_ts_, ObTimeUtility::current_time());
if (fetch_prefetch) {
table_node->prefetch_node_.cache_start_ = start_inclusive;
table_node->prefetch_node_.cache_end_ = std::min(max_value, end_inclusive);
} else {
// there is no prefetch_node here
// because we must have tried to allocate cache handle from curr_node and prefetch_node
// before allocate new cache node
// if we allocate new cache node, curr_node and prefetch_node should have been combined;
// and prefetch_node should have been reset
CacheNode new_node;
new_node.cache_start_ = start_inclusive;
new_node.cache_end_ = std::min(max_value, end_inclusive);
if (OB_FAIL(table_node->curr_node_.combine_cache_node(new_node))) {
LOG_WARN("failed to combine cache node", K(*table_node), K(new_node), K(ret));
} else if (0 == table_node->next_value_) {
table_node->next_value_ = start_inclusive;
}
}
}
// ignore error for prefetch, cache is enough here
// other thread will try next time
if (fetch_prefetch && OB_FAIL(ret)) {
LOG_WARN("failed to prefetch; ignore this", K(ret));
ret = OB_SUCCESS;
}
}
return ret;
}
int ObAutoincrementService::set_pre_op_timeout(common::ObTimeoutCtx &ctx)
{
int ret = OB_SUCCESS;
int64_t abs_timeout_us = ctx.get_abs_timeout();
if (abs_timeout_us < 0) {
abs_timeout_us = ObTimeUtility::current_time() + PRE_OP_TIMEOUT;
}
if (THIS_WORKER.get_timeout_ts() > 0 && THIS_WORKER.get_timeout_ts() < abs_timeout_us) {
abs_timeout_us = THIS_WORKER.get_timeout_ts();
}
if (OB_FAIL(ctx.set_abs_timeout(abs_timeout_us))) {
LOG_WARN("set timeout failed", K(ret), K(abs_timeout_us));
} else if (ctx.is_timeouted()) {
ret = OB_TIMEOUT;
LOG_WARN("is timeout",
K(ret),
"abs_timeout", ctx.get_abs_timeout(),
"this worker timeout ts", THIS_WORKER.get_timeout_ts());
}
return ret;
}
//FIXME: use location_service instead
// TODO shengle
int ObAutoincrementService::get_server_set(const uint64_t tenant_id,
const uint64_t table_id,
common::hash::ObHashSet<ObAddr> &server_set,
const bool get_follower)
{
int ret = OB_SUCCESS;
const int64_t expire_renew_time = INT64_MAX; // means must renew location
bool is_cache_hit = false;
ObSchemaGetterGuard schema_guard;
bool is_found = false;
ObLSID ls_id;
ObLSLocation ls_loc;
ObSEArray<ObTabletID, 4> tablet_ids;
ObSEArray<ObLSLocation, 4> ls_locations;
const ObSimpleTableSchemaV2 *table_schema = nullptr;
if (OB_ISNULL(schema_service_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(schema_service_));
} else if (OB_FAIL(schema_service_->get_tenant_schema_guard(tenant_id,
schema_guard))) {
LOG_WARN("failed to get tenant schema guard", K(ret), K(tenant_id));
} else if (OB_FAIL(schema_guard.get_simple_table_schema(tenant_id, table_id, table_schema))) {
LOG_WARN("fail to get table schema", K(ret),K(table_id));
} else if (OB_ISNULL(table_schema)) {
ret = OB_SCHEMA_EAGAIN;
LOG_WARN("fail to get table schema", KR(ret));
} else if (OB_FAIL(table_schema->get_tablet_ids(tablet_ids))) {
LOG_WARN("fail to get tablet ids", K(ret));
} else {
ObLSLocation ls_loc;
for (int64_t i = 0; OB_SUCC(ret) && i < tablet_ids.count(); i++) {
if (OB_FAIL(GCTX.location_service_->get(tenant_id,
tablet_ids.at(i),
expire_renew_time,
is_cache_hit,
ls_id))) {
LOG_WARN("fail to get ls id", K(ret), K(tenant_id), K(tablet_ids.at(i)));
} else if (OB_FAIL(GCTX.location_service_->get(GCONF.cluster_id,
tenant_id,
ls_id,
0, /*not force to renew*/
is_cache_hit,
ls_loc))) {
LOG_WARN("failed to get all partitions' locations", K(table_id), K(ret));
}
OZ(ls_locations.push_back(ls_loc));
}
}
if (OB_SUCC(ret)) {
LOG_TRACE("get partition locations", K(ls_locations), K(ret));
ObLSReplicaLocation location;
for(int64_t i = 0; OB_SUCC(ret) && i < ls_locations.count(); ++i) {
if (!get_follower) {
location.reset();
if (OB_FAIL(ls_locations.at(i).get_leader(location))) {
LOG_WARN("failed to get partition leader", "location", ls_locations.at(i), K(ret));
} else {
int err = OB_SUCCESS;
err = server_set.set_refactored(location.get_server());
if (OB_SUCCESS != err && OB_HASH_EXIST != err) {
ret = err;
LOG_WARN("failed to add element to set", "server", location.get_server(), K(ret));
}
}
} else {
const ObIArray<ObLSReplicaLocation> &replica_locations = ls_locations.at(i).get_replica_locations();
for (int j = 0; j < replica_locations.count(); ++j) {
int err = OB_SUCCESS;
err = server_set.set_refactored(replica_locations.at(j).get_server());
if (OB_SUCCESS != err && OB_HASH_EXIST != err) {
ret = err;
LOG_WARN("failed to add element to set",
"server", replica_locations.at(j).get_server(), K(ret));
}
}
}
}
}
LOG_DEBUG("sync server_set", K(server_set), K(ret));
return ret;
}
int ObAutoincrementService::sync_insert_value_order(AutoincParam &param,
CacheHandle *&cache_handle,
const uint64_t insert_value)
{
int ret = OB_SUCCESS;
const uint64_t tenant_id = param.tenant_id_;
const uint64_t table_id = param.autoinc_table_id_;
const uint64_t column_id = param.autoinc_col_id_;
const ObObjType column_type = param.autoinc_col_type_;
const uint64_t max_value = get_max_value(column_type);
const uint64_t part_num = param.autoinc_table_part_num_;
const int64_t autoinc_version = param.autoinc_version_;
uint64_t global_sync_value = 0;
AutoincKey key(tenant_id, table_id, column_id);
uint64_t value_to_sync = insert_value;
if (value_to_sync > max_value) {
value_to_sync = max_value;
}
if (OB_FAIL(global_autoinc_service_.local_push_to_global_value(
key, max_value, value_to_sync, autoinc_version, global_sync_value))) {
LOG_WARN("fail sync value to global", K(key), K(insert_value), K(ret));
} else if (NULL != cache_handle) {
LOG_DEBUG("insert value, generate next val",
K(insert_value), K(cache_handle->prefetch_end_), K(cache_handle->next_value_));
if (insert_value < cache_handle->prefetch_end_) {
if (insert_value >= cache_handle->next_value_) {
if (OB_FAIL(calc_next_value(insert_value + 1,
param.autoinc_offset_,
param.autoinc_increment_,
cache_handle->next_value_))) {
LOG_WARN("failed to calc next value", K(cache_handle), K(param), K(ret));
}
LOG_DEBUG("generate next value when sync_insert_value", K(insert_value), K(cache_handle->next_value_));
}
} else {
// release handle No.
handle_allocator_.free(cache_handle);
cache_handle = NULL;
// invalid cache handle; record count
param.autoinc_intervals_count_++;
}
}
return ret;
}
/* core logic:
* 1. write insert_value to global storage
* - only if insert_value > local_sync_
* 2. notify other servers that a larger value written to global storage
* 3. update local table node
*/
int ObAutoincrementService::sync_insert_value_noorder(AutoincParam &param,
CacheHandle *&cache_handle,
const uint64_t insert_value)
{
int ret = OB_SUCCESS;
const uint64_t tenant_id = param.tenant_id_;
const uint64_t table_id = param.autoinc_table_id_;
const uint64_t column_id = param.autoinc_col_id_;
const ObObjType column_type = param.autoinc_col_type_;
const uint64_t max_value = get_max_value(column_type);
const uint64_t part_num = param.autoinc_table_part_num_;
const int64_t autoinc_version = param.autoinc_version_;
TableNode *table_node = NULL;
LOG_DEBUG("begin to sync insert value globally", K(param), K(insert_value));
if (OB_FAIL(get_table_node(param, table_node))) {
LOG_WARN("table node should exist", K(param), K(ret));
} else {
// logic:
// 1. we should not compare insert_value with local cache node. it is meaningless.
// e.g. insert_value = 15, A caches [20,30), B caches [0-10), you should not compare
// insert_value with A without any information on B
// 2. local_sync_ semantics：we can make sure that other observer has seen a
// sync value larger than or equal to local_sync.
// If observer has synced with global, we can predicate:
// a newly inserted value less than local sync don't need to push to global. As we can
// make a good guess that a larger value had already pushed to global by someone else.
// 3. only if insert_value > local_sync_ & insert_value > global_sync:
// we can write insert_value into global storage. otherwise, don't sync
//
uint64_t global_sync_value = 0; // piggy back global value when we sync out insert_value
AutoincKey key(tenant_id, table_id, column_id);
// compare insert_value with local_sync/global_sync
if (insert_value <= ATOMIC_LOAD(&table_node->local_sync_)) {
// do nothing
} else {
const bool is_order = param.autoinc_mode_is_order_;
// For ORDER mode, the local cache_size is always 1, and the central(remote) cache_size
// is the configuration value.
const uint64_t local_cache_size = is_order ? 1 : param.auto_increment_cache_size_;
uint64_t value_to_sync = calc_next_cache_boundary(insert_value, local_cache_size, max_value);
if (OB_FAIL(distributed_autoinc_service_.local_push_to_global_value(key, max_value,
value_to_sync, autoinc_version, global_sync_value))) {
LOG_WARN("fail sync value to global", K(key), K(insert_value), K(ret));
} else {
if (OB_FAIL(alloc_autoinc_try_lock(table_node->alloc_mutex_))) {
LOG_WARN("fail to get alloc mutex", K(ret));
} else {
if (value_to_sync <= global_sync_value) {
atomic_update(table_node->local_sync_, global_sync_value);
atomic_update(table_node->last_refresh_ts_, ObTimeUtility::current_time());
} else {
atomic_update(table_node->local_sync_, value_to_sync);
if (!is_order && OB_FAIL(sync_value_to_other_servers(param, value_to_sync))) {
LOG_WARN("fail sync value to other servers", K(ret));
}
}
table_node->alloc_mutex_.unlock();
}
}
}
// INSERT INTO t1 VALUES (null), (null), (4), (null), (null);
// 1 2 4 5 6
// assume cache_handle saves [1, 5]
// in this case, values will be allocated as above. in order to generate the forth value '5',
// we need following logic:
if (OB_SUCC(ret)) {
if (NULL != cache_handle) {
LOG_DEBUG("insert value, generate next val",
K(insert_value), K(cache_handle->prefetch_end_), K(cache_handle->next_value_));
if (insert_value < cache_handle->prefetch_end_) {
if (insert_value >= cache_handle->next_value_) {
if (OB_FAIL(calc_next_value(insert_value + 1,
param.autoinc_offset_,
param.autoinc_increment_,
cache_handle->next_value_))) {
LOG_WARN("failed to calc next value", K(cache_handle), K(param), K(ret));
}
LOG_DEBUG("generate next value when sync_insert_value", K(insert_value), K(cache_handle->next_value_));
}
} else {
// release handle No.
handle_allocator_.free(cache_handle);
cache_handle = NULL;
// invalid cache handle; record count
param.autoinc_intervals_count_++;
}
}
}
if (OB_SUCC(ret)) {
// Note: when insert_value is larger than current cache value, do we really need to
// refresh local cache? What if other thread in this server is refreshing local cache?
// - if we don't, and other thread fetchs a small cache value, it is not OK.
// SO, we must fetch table node here.
// syncing insert_value is not the common case. perf acceptable
if (OB_FAIL(alloc_autoinc_try_lock(table_node->alloc_mutex_))) {
LOG_WARN("fail to get alloc mutex", K(ret));
} else {
if (insert_value >= table_node->curr_node_.cache_end_
&& insert_value >= table_node->prefetch_node_.cache_end_) {
TableNode mock_node;
if (param.autoinc_desired_count_ <= 0) {
// do nothing
} else if (OB_FAIL(fetch_table_node(param, &mock_node))) {
LOG_WARN("failed to alloc table node", K(param), K(ret));
} else {
table_node->prefetch_node_.reset();
if (mock_node.curr_node_.cache_end_ > table_node->curr_node_.cache_end_) {
table_node->curr_node_.cache_start_ = mock_node.curr_node_.cache_start_;
table_node->curr_node_.cache_end_ = mock_node.curr_node_.cache_end_;
}
LOG_INFO("fetch table node success", K(param), K(*table_node));
}
}
table_node->alloc_mutex_.unlock();
}
}
}
// table node must be reverted after get to decrement reference count
if (NULL != table_node) {
node_map_.revert(table_node);
}
return ret;
}
int ObAutoincrementService::sync_value_to_other_servers(
AutoincParam &param,
uint64_t insert_value)
{
int ret = OB_SUCCESS;
// sync observer where table partitions exist
LOG_DEBUG("begin to sync other servers", K(param));
ObAutoincSyncArg arg;
arg.tenant_id_ = param.tenant_id_;
arg.table_id_ = param.autoinc_table_id_;
arg.column_id_ = param.autoinc_col_id_;
arg.sync_value_ = insert_value;
ObHashSet<ObAddr> server_set;
if (OB_FAIL(server_set.create(PARTITION_LOCATION_SET_BUCKET_NUM))) {
LOG_WARN("failed to create hash set", K(param), K(ret));
} else {
if (OB_FAIL(get_server_set(param.tenant_id_, param.autoinc_table_id_, server_set))) {
SHARE_LOG(WARN, "failed to get table partitions server set", K(ret));
}
if (OB_SUCC(ret)) {
LOG_DEBUG("server_set after remove self", K(server_set), K(ret));
ObHashSet<ObAddr>::iterator iter;
// this operation succeeds in two case:
// 1. sync to all servers (without timeout)
// 2. reach SYNC_TIMEOUT (without worker timeout)
// other cases won't succeed:
// 1. worker timeout
// 2. rpc calls return failure (not OB_TIMEOUT)
int64_t sync_us = 0;
const int64_t start_us = ObTimeUtility::current_time();
const int64_t sync_timeout = SYNC_OP_TIMEOUT + TIME_SKEW;
for(iter = server_set.begin(); OB_SUCC(ret) && iter != server_set.end(); ++iter) {
LOG_INFO("send rpc call to other observers", "server", iter->first);
sync_us = THIS_WORKER.get_timeout_remain();
if (sync_us > sync_timeout) {
sync_us = sync_timeout;
}
// TODO: send sync_value to other servers
if (OB_FAIL(srv_proxy_->to(iter->first)
.timeout(sync_us)
.refresh_sync_value(arg))) {
if (is_rpc_error(ret)) {
LOG_WARN("sync rpc call time out", "server", iter->first, K(sync_us), K(param), K(ret));
if (!THIS_WORKER.is_timeout()) {
// reach SYNC_TIMEOUT, go on
// ignore time out
ret = OB_SUCCESS;
break;
}
} else {
LOG_WARN("failed to send rpc call", K(param), K(ret));
}
} else if (ObTimeUtility::current_time() - start_us >= sync_timeout) {
// reach SYNC_TIMEOUT, go on
LOG_INFO("reach SYNC_TIMEOUT, go on", "server", iter->first, K(param), K(ret));
break;
} else if (THIS_WORKER.is_timeout()) {
ret = OB_TIMEOUT;
LOG_WARN("failed to sync insert value; worker timeout", K(param), K(ret));
break;
}
}
}
}
return ret;
}
// sync last user specified value first(compatible with MySQL)
int ObAutoincrementService::sync_insert_value_global(AutoincParam &param)
{
int ret = OB_SUCCESS;
if (0 != param.global_value_to_sync_) {
if (param.global_value_to_sync_ < param.autoinc_auto_increment_) {
// do nothing, insert value directly
} else if (param.autoinc_mode_is_order_) {
if (OB_FAIL(sync_insert_value_order(param,
param.cache_handle_,
param.global_value_to_sync_))) {
SQL_ENG_LOG(WARN, "failed to sync insert value",
"insert_value", param.global_value_to_sync_, K(ret));
}
} else {
if (OB_FAIL(sync_insert_value_noorder(param,
param.cache_handle_,
param.global_value_to_sync_))) {
SQL_ENG_LOG(WARN, "failed to sync insert value",
"insert_value", param.global_value_to_sync_, K(ret));
}
}
param.global_value_to_sync_ = 0;
}
return ret;
}
// sync last user specified value in stmt
int ObAutoincrementService::sync_insert_value_local(AutoincParam &param)
{
int ret = OB_SUCCESS;
if (param.sync_flag_) {
if (param.global_value_to_sync_ < param.value_to_sync_) {
param.global_value_to_sync_ = param.value_to_sync_;
}
param.sync_flag_ = false;
}
return ret;
}
int ObAutoincrementService::sync_auto_increment_all(const uint64_t tenant_id,
const uint64_t table_id,
const uint64_t column_id,
const uint64_t sync_value)
{
int ret = OB_SUCCESS;
LOG_INFO("begin to sync auto_increment value", K(sync_value), K(tenant_id), K(table_id));
// if (OB_SUCC(ret)) {
// AutoincKey key(tenant_id, table_id, column_id);
// if(OB_FAIL(sync_table_auto_increment(tenant_id, key, sync_value))) {
// LOG_WARN("fail sync table auto increment value", K(ret));
// }
// }
if (OB_SUCC(ret)) {
// sync observer where table partitions exist
ObAutoincSyncArg arg;
arg.tenant_id_ = tenant_id;
arg.table_id_ = table_id;
arg.column_id_ = column_id;
arg.sync_value_ = sync_value;
ObHashSet<ObAddr> server_set;
if (OB_FAIL(server_set.create(PARTITION_LOCATION_SET_BUCKET_NUM))) {
LOG_WARN("failed to create hash set", K(ret));
} else {
if (OB_FAIL(get_server_set(tenant_id, table_id, server_set, true))) {
SHARE_LOG(WARN, "failed to get table partitions server set", K(ret));
}
LOG_DEBUG("sync server_set", K(server_set), K(ret));
if (OB_SUCC(ret)) {
const int64_t sync_timeout = SYNC_OP_TIMEOUT + TIME_SKEW;
ObHashSet<ObAddr>::iterator iter;
for(iter = server_set.begin(); OB_SUCC(ret) && iter != server_set.end(); ++iter) {
LOG_DEBUG("send rpc call to other observers", "server", iter->first);
if (OB_FAIL(srv_proxy_->to(iter->first)
.timeout(sync_timeout)
.refresh_sync_value(arg))) {
if (is_rpc_error(ret)) {
// ignore time out, go on
LOG_WARN("rpc call time out", "server", iter->first, K(ret));
if (!THIS_WORKER.is_timeout()) {
// reach SYNC_TIMEOUT, go on
// ignore time out
ret = OB_SUCCESS;
break;
}
} else {
LOG_WARN("failed to send rpc call", K(ret));
}
}
}
}
}
}
return ret;
}
int ObAutoincrementService::fetch_global_sync(const uint64_t tenant_id,
const uint64_t table_id,
const uint64_t column_id,
TableNode &table_node,
const bool sync_presync)
{
int ret = OB_SUCCESS;
uint64_t sync_value = 0;
// set timeout for presync
ObTimeoutCtx ctx;
if (sync_presync) {
if (OB_FAIL(set_pre_op_timeout(ctx))) {
LOG_WARN("failed to set timeout", K(ret));
}
}
if (OB_SUCC(ret)) {
AutoincKey key(tenant_id, table_id, column_id);
if (OB_FAIL(distributed_autoinc_service_.local_sync_with_global_value(key, table_node.autoinc_version_, sync_value))) {
LOG_WARN("fail refresh global value", K(ret));
} else {
atomic_update(table_node.local_sync_, sync_value);
atomic_update(table_node.last_refresh_ts_, ObTimeUtility::current_time());
}
}
// ignore error for presync
// other thread will try next time
if (sync_presync && OB_FAIL(ret)) {
LOG_WARN("failed to presync; ignore this", K(ret));
ret = OB_SUCCESS;
}
return ret;
}
uint64_t ObAutoincrementService::calc_next_cache_boundary(
uint64_t insert_value,
uint64_t cache_size,
uint64_t max_value)
{
uint64_t new_next_boundary = 0;
const uint64_t insert_value_bak = insert_value;
// round up insert_value except cache_size. for example, when cache size is 1000,
// we will get the following results for different insert_values:
// insert_value = 999 -> new_next_boundary = 1000;
// insert_value = 1000 -> new_next_boundary = 1000;
// insert_value = 1001 -> new_next_boundary = 2000;
uint64_t v = (insert_value % cache_size == 0) ? 0 : 1;
insert_value = (insert_value / cache_size + v) * cache_size;
if (insert_value < insert_value_bak || insert_value > max_value) {
new_next_boundary = max_value;
} else {
new_next_boundary = insert_value;
}
return new_next_boundary;
}
int ObAutoincrementService::calc_next_value(const uint64_t last_next_value,
const uint64_t offset,
const uint64_t increment,
uint64_t &new_next_value)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(increment <= 0)) {
//这里有除0错误，需要防御检查
ret = OB_ERR_UNEXPECTED;
LOG_WARN("increment is invalid", K(ret), K(increment));
} else {
uint64_t real_offset = offset;
if (real_offset > increment) {
real_offset = 0;
}
if (last_next_value <= real_offset) {
new_next_value = real_offset;
} else {
new_next_value = ((last_next_value - real_offset + increment - 1) / increment) * increment + real_offset;
}
if (new_next_value < last_next_value) {
new_next_value = UINT64_MAX;
}
}
LOG_DEBUG("calc next value", K(new_next_value), K(ret));
return ret;
}
// Tow params control the starting value
// - auto_increment_increment controls the interval between successive column values.
// - auto_increment_offset determines the starting point for the AUTO_INCREMENT column value.
//
// When the auto value reaches its end, it will keep producing the max value.
// The max value is decided by:
//
// If either of these variables is changed, and then new rows inserted into a table containing an
// AUTO_INCREMENT column, the results may seem counterintuitive because the series of AUTO_INCREMENT
// values is calculated without regard to any values already present in the column, and the next
// value inserted is the least value in the series that is greater than the maximum existing value
// in the AUTO_INCREMENT column. The series is calculated like this:
//
// prev_value = auto_increment_offset + N × auto_increment_increment
//
// More details:
// https://dev.mysql.com/doc/refman/5.6/en/replication-options-master.html#sysvar_auto_increment_increment
//
// The doc does not mention one case: when offset > max_value, the formulator is not right.
// a bug is recorded here:
int ObAutoincrementService::calc_prev_value(const uint64_t max_value,
const uint64_t offset,
const uint64_t increment,
uint64_t &prev_value)
{
int ret = OB_SUCCESS;
if (max_value <= offset) {
prev_value = max_value;
} else {
if (0 == increment) {
ret = OB_ERR_UNEXPECTED;
} else {
prev_value = ((max_value - offset) / increment) * increment + offset;
}
}
LOG_INFO("out of range for column. calc prev value",
K(prev_value), K(max_value), K(offset), K(increment));
return ret;
}
int ObAutoincrementService::get_sequence_value(const uint64_t tenant_id,
const uint64_t table_id,
const uint64_t column_id,
const bool is_order,
const int64_t autoinc_version,
uint64_t &seq_value)
{
int ret = OB_SUCCESS;
AutoincKey key;
key.tenant_id_ = tenant_id;
key.table_id_ = table_id;
key.column_id_ = column_id;
if (is_order && OB_FAIL(global_autoinc_service_.get_sequence_value(key, autoinc_version, seq_value))) {
LOG_WARN("global autoinc service get sequence value failed", K(ret));
} else if (!is_order &&
OB_FAIL(distributed_autoinc_service_.get_sequence_value(key, autoinc_version, seq_value))) {
LOG_WARN("distributed autoinc service get sequence value failed", K(ret));
}
return ret;
}
// used for __tenant_virtual_all_table only
int ObAutoincrementService::get_sequence_values(
const uint64_t tenant_id,
const ObIArray<AutoincKey> &order_autokeys,
const ObIArray<AutoincKey> &noorder_autokeys,
const ObIArray<int64_t> &order_autoinc_versions,
const ObIArray<int64_t> &noorder_autoinc_versions,
ObHashMap<AutoincKey, uint64_t> &seq_values)
{
int ret = OB_SUCCESS;
if (OB_FAIL(global_autoinc_service_.get_auto_increment_values(
tenant_id, order_autokeys, order_autoinc_versions, seq_values))) {
LOG_WARN("global_autoinc_service_ get sequence values failed", K(ret));
} else if (OB_FAIL(distributed_autoinc_service_.get_auto_increment_values(
tenant_id, noorder_autokeys, noorder_autoinc_versions, seq_values))) {
LOG_WARN("distributed_autoinc_service_ get sequence values failed", K(ret));
}
return ret;
}
int ObInnerTableGlobalAutoIncrementService::get_value(
const AutoincKey &key,
const uint64_t offset,
const uint64_t increment,
const uint64_t max_value,
const uint64_t table_auto_increment,
const uint64_t desired_count,
const uint64_t cache_size,
const int64_t &autoinc_version,
uint64_t &sync_value,
uint64_t &start_inclusive,
uint64_t &end_inclusive)
{
UNUSED(cache_size);
int ret = OB_SUCCESS;
uint64_t sync_value_from_inner_table = 0;
ret = inner_table_proxy_.next_autoinc_value(
key, offset, increment, table_auto_increment, max_value, desired_count, autoinc_version,
start_inclusive, end_inclusive, sync_value_from_inner_table);
if (OB_SUCC(ret)) {
if (table_auto_increment != 0 && table_auto_increment - 1 > sync_value_from_inner_table) {
sync_value = table_auto_increment -1;
} else {
sync_value = sync_value_from_inner_table;
}
}
return ret;
}
int ObInnerTableGlobalAutoIncrementService::get_sequence_value(const AutoincKey &key,
const int64_t &autoinc_version,
uint64_t &sequence_value)
{
uint64_t sync_value = 0; // unused
return inner_table_proxy_.get_autoinc_value(key, autoinc_version, sequence_value, sync_value);
}
int ObInnerTableGlobalAutoIncrementService::get_auto_increment_values(
const uint64_t tenant_id,
const common::ObIArray<AutoincKey> &autoinc_keys,
const common::ObIArray<int64_t> &autoinc_versions,
common::hash::ObHashMap<AutoincKey, uint64_t> &seq_values)
{
UNUSED(autoinc_versions);
return inner_table_proxy_.get_autoinc_value_in_batch(tenant_id, autoinc_keys, seq_values);
}
int ObInnerTableGlobalAutoIncrementService::local_push_to_global_value(
const AutoincKey &key,
const uint64_t max_value,
const uint64_t insert_value,
const int64_t &autoinc_version,
uint64_t &sync_value)
{
uint64_t seq_value = 0; // unused, * MUST * set seq_value to 0 here.
return inner_table_proxy_.sync_autoinc_value(key, insert_value, max_value, autoinc_version,
seq_value, sync_value);
}
int ObInnerTableGlobalAutoIncrementService::local_sync_with_global_value(
const AutoincKey &key,
const int64_t &autoinc_version,
uint64_t &sync_value)
{
uint64_t seq_value = 0; // unused
return inner_table_proxy_.get_autoinc_value(key, autoinc_version, seq_value, sync_value);
}
int ObRpcGlobalAutoIncrementService::init(
const common::ObAddr &addr,
rpc::frame::ObReqTransport *req_transport)
{
int ret = OB_SUCCESS;
if (is_inited_) {
ret = OB_INIT_TWICE;
LOG_WARN("ObRpcGlobalAutoIncrementService inited twice", KR(ret));
} else if (!addr.is_valid()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", KR(ret), K(addr));
} else if (OB_FAIL(gais_request_rpc_proxy_.init(req_transport, addr))) {
LOG_WARN("rpc proxy init failed", K(ret), K(req_transport), K(addr));
} else if (OB_FAIL(gais_request_rpc_.init(&gais_request_rpc_proxy_, addr))) {
LOG_WARN("response rpc init failed", K(ret), K(addr));
} else if (OB_FAIL(gais_client_.init(addr, &gais_request_rpc_))) {
LOG_WARN("init client failed", K(ret));
}
return ret;
}
int ObRpcGlobalAutoIncrementService::get_value(
const AutoincKey &key,
const uint64_t offset,
const uint64_t increment,
const uint64_t max_value,
const uint64_t table_auto_increment,
const uint64_t desired_count,
const uint64_t cache_size,
const int64_t &autoinc_version,
uint64_t &sync_value,
uint64_t &start_inclusive,
uint64_t &end_inclusive)
{
return gais_client_.get_value(key, offset, increment, max_value, table_auto_increment,
desired_count, cache_size, autoinc_version,sync_value,
start_inclusive, end_inclusive);
}
int ObRpcGlobalAutoIncrementService::get_sequence_value(const AutoincKey &key,
const int64_t &autoinc_version,
uint64_t &sequence_value)
{
return gais_client_.get_sequence_value(key, autoinc_version, sequence_value);
}
int ObRpcGlobalAutoIncrementService::get_auto_increment_values(
const uint64_t tenant_id,
const common::ObIArray<AutoincKey> &autoinc_keys,
const common::ObIArray<int64_t> &autoinc_versions,
common::hash::ObHashMap<AutoincKey, uint64_t> &seq_valuesm)
{
UNUSED(tenant_id);
return gais_client_.get_auto_increment_values(autoinc_keys, autoinc_versions, seq_valuesm);
}
int ObRpcGlobalAutoIncrementService::local_push_to_global_value(
const AutoincKey &key,
const uint64_t max_value,
const uint64_t value,
const int64_t &autoinc_version,
uint64_t &global_sync_value)
{
return gais_client_.local_push_to_global_value(key, max_value, value, autoinc_version, global_sync_value);
}
int ObRpcGlobalAutoIncrementService::local_sync_with_global_value(
const AutoincKey &key,
const int64_t &autoinc_version,
uint64_t &value)
{
return gais_client_.local_sync_with_global_value(key, autoinc_version, value);
}
int ObRpcGlobalAutoIncrementService::clear_global_autoinc_cache(const AutoincKey &key)
{
return gais_client_.clear_global_autoinc_cache(key);
}
int ObAutoIncInnerTableProxy::check_inner_autoinc_version(const int64_t &request_autoinc_version,
const int64_t &inner_autoinc_version,
const AutoincKey &key)
{
int ret = OB_SUCCESS;
if (0 == request_autoinc_version || 0 == inner_autoinc_version) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("autoinc version is zero", KR(ret), K(request_autoinc_version), K(inner_autoinc_version));
// inner table did not update
} else if (OB_UNLIKELY(inner_autoinc_version < request_autoinc_version)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("inner_autoinc_version can not less than autoinc_version", KR(ret), K(key),
K(inner_autoinc_version), K(request_autoinc_version));
// old request
} else if (OB_UNLIKELY(inner_autoinc_version > request_autoinc_version)) {
ret = OB_AUTOINC_CACHE_NOT_EQUAL;
LOG_WARN("inner_autoinc_version is greater than autoinc_version, request needs retry", KR(ret), K(key),
K(inner_autoinc_version), K(request_autoinc_version));
}
return ret;
}
int ObAutoIncInnerTableProxy::next_autoinc_value(const AutoincKey &key,
const uint64_t offset,
const uint64_t increment,
const uint64_t base_value,
const uint64_t max_value,
const uint64_t desired_count,
const int64_t &autoinc_version,
uint64_t &start_inclusive,
uint64_t &end_inclusive,
uint64_t &sync_value)
{
int ret = OB_SUCCESS;
ObMySQLTransaction trans;
bool with_snap_shot = true;
const uint64_t tenant_id = key.tenant_id_;
const uint64_t table_id = key.table_id_;
const uint64_t column_id = key.column_id_;
uint64_t sequence_value = 0;
int64_t inner_autoinc_version = OB_INVALID_VERSION;
int64_t tmp_autoinc_version = get_modify_autoinc_version(autoinc_version);
if (OB_ISNULL(mysql_proxy_)) {
ret = OB_NOT_INIT;
LOG_WARN("mysql proxy is null", K(ret));
} else if (OB_FAIL(trans.start(mysql_proxy_, tenant_id, with_snap_shot))) {
LOG_WARN("failed to start transaction", K(ret), K(tenant_id));
} else {
int sql_len = 0;
SMART_VAR(char[OB_MAX_SQL_LENGTH], sql) {
const uint64_t exec_tenant_id = tenant_id;
const char *table_name = OB_ALL_AUTO_INCREMENT_TNAME;
sql_len = snprintf(sql, OB_MAX_SQL_LENGTH,
" SELECT sequence_key, sequence_value, sync_value, truncate_version FROM %s WHERE tenant_id = %lu AND sequence_key = %lu AND column_id = %lu FOR UPDATE",
table_name,
ObSchemaUtils::get_extract_tenant_id(tenant_id, tenant_id),
ObSchemaUtils::get_extract_schema_id(tenant_id, table_id),
column_id);
if (sql_len >= OB_MAX_SQL_LENGTH || sql_len <= 0) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("failed to format sql. size not enough");
} else {
int64_t fetch_table_id = OB_INVALID_ID;
{ // make sure %res destructed before execute other sql in the same transaction
SMART_VAR(ObMySQLProxy::MySQLResult, res) {
ObMySQLResult *result = NULL;
ObISQLClient *sql_client = &trans;
uint64_t sequence_table_id = OB_ALL_AUTO_INCREMENT_TID;
ObSQLClientRetryWeak sql_client_retry_weak(sql_client,
exec_tenant_id,
sequence_table_id);
if (OB_FAIL(sql_client_retry_weak.read(res, exec_tenant_id, sql))) {
LOG_WARN(" failed to read data", K(ret));
} else if (NULL == (result = res.get_result())) {
LOG_WARN("failed to get result", K(ret));
ret = OB_ERR_UNEXPECTED;
} else if (OB_FAIL(result->next())) {
LOG_WARN("failed to get next", K(ret));
if (OB_ITER_END == ret) {
// auto-increment column has been deleted
ret = OB_SCHEMA_ERROR;
LOG_WARN("failed to get next", K(ret));
}
} else {
if (OB_FAIL(result->get_int(0l, fetch_table_id))) {
LOG_WARN("fail to get int_value.", K(ret));
} else if (OB_FAIL(result->get_uint(1l, sequence_value))) {
LOG_WARN("fail to get int_value.", K(ret));
} else if (OB_FAIL(result->get_uint(2l, sync_value))) {
LOG_WARN("fail to get int_value.", K(ret));
} else if (OB_FAIL(result->get_int(3l, inner_autoinc_version))) {
LOG_WARN("fail to get inner_autoinc_version.", K(ret));
} else if (OB_FAIL(check_inner_autoinc_version(tmp_autoinc_version, inner_autoinc_version, key))) {
LOG_WARN("fail to check inner_autoinc_version", KR(ret));
} else {
if (sync_value >= max_value) {
sequence_value = max_value;
} else {
sequence_value = std::max(sequence_value, sync_value + 1);
}
if (base_value > sequence_value) {
sequence_value = base_value;
}
}
if (OB_SUCC(ret)) {
int tmp_ret = OB_SUCCESS;
if (OB_ITER_END != (tmp_ret = result->next())) {
if (OB_SUCCESS == tmp_ret) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("more than one row", K(ret), K(tenant_id), K(table_id), K(column_id));
} else {
ret = tmp_ret;
LOG_WARN("fail to iter next row", K(ret), K(tenant_id), K(table_id),
K(column_id));
}
}
}
}
}
}
if (OB_SUCC(ret)) {
uint64_t curr_new_value = 0;
if (OB_FAIL(ObAutoincrementService::calc_next_value(sequence_value, offset, increment, curr_new_value))) {
LOG_WARN("fail to get next value.", K(ret));
} else {
uint64_t next_sequence_value = 0;
if (max_value < desired_count || curr_new_value >= max_value - desired_count) {
end_inclusive = max_value;
next_sequence_value = max_value;
if (OB_UNLIKELY(curr_new_value > max_value)) {
curr_new_value = max_value;
}
} else {
end_inclusive = curr_new_value + desired_count - 1;
next_sequence_value = curr_new_value + desired_count;
if (OB_UNLIKELY(end_inclusive >= max_value || end_inclusive < curr_new_value /* overflow */)) {
end_inclusive = max_value;
next_sequence_value = max_value;
}
}
start_inclusive = curr_new_value;
LOG_DEBUG("update next value",
K(desired_count), K(next_sequence_value), K(start_inclusive), K(end_inclusive));
sql_len = snprintf(sql, OB_MAX_SQL_LENGTH,
"UPDATE %s SET sequence_value = %lu, gmt_modified = now(6)"
" WHERE tenant_id = %lu AND sequence_key = %lu AND column_id = %lu AND truncate_version = %ld",
table_name,
next_sequence_value,
OB_INVALID_TENANT_ID,
table_id,
column_id,
inner_autoinc_version);
int64_t affected_rows = 0;
if (sql_len >= OB_MAX_SQL_LENGTH || sql_len <= 0) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("failed to format sql. size not enough");
} else if (GCTX.is_standby_cluster() && OB_SYS_TENANT_ID != exec_tenant_id) {
ret = OB_OP_NOT_ALLOW;
LOG_WARN("can't write sys table now", K(ret), K(exec_tenant_id));
} else if (OB_FAIL(trans.write(exec_tenant_id, sql, affected_rows))) {
LOG_WARN("failed to write data", K(ret));
} else if (affected_rows != 1) {
LOG_WARN("failed to update sequence value",
K(tenant_id), K(table_id), K(column_id), K(ret));
}
}
}
}
}
// commit transaction or rollback
if (OB_SUCC(ret)) {
if (OB_FAIL(trans.end(true))) {
LOG_WARN("fail to commit transaction.", K(ret));
}
} else {
int err = OB_SUCCESS;
if (OB_SUCCESS != (err = trans.end(false))) {
LOG_WARN("fail to rollback transaction. ", K(err));
}
}
}
LOG_DEBUG("get_value done", K(max_value), K(sync_value), K(start_inclusive), K(end_inclusive));
return ret;
}
int ObAutoIncInnerTableProxy::get_autoinc_value(const AutoincKey &key,
const int64_t &autoinc_version,
uint64_t &seq_value,
uint64_t &sync_value)
{
int ret = OB_SUCCESS;
const uint64_t tenant_id = key.tenant_id_;
const int64_t tmp_autoinc_version = get_modify_autoinc_version(autoinc_version);
SMART_VARS_2((ObMySQLProxy::MySQLResult, res), (char[OB_MAX_SQL_LENGTH], sql)) {
ObMySQLResult *result = NULL;
int sql_len = 0;
const uint64_t exec_tenant_id = tenant_id;
const char *table_name = OB_ALL_AUTO_INCREMENT_TNAME;
sql_len = snprintf(sql, OB_MAX_SQL_LENGTH,
" SELECT sequence_value, sync_value, truncate_version FROM %s"
" WHERE tenant_id = %lu AND sequence_key = %lu AND column_id = %lu",
table_name,
ObSchemaUtils::get_extract_tenant_id(exec_tenant_id, tenant_id),
ObSchemaUtils::get_extract_schema_id(exec_tenant_id, key.table_id_),
key.column_id_);
ObISQLClient *sql_client = mysql_proxy_;
uint64_t sequence_table_id = OB_ALL_AUTO_INCREMENT_TID;
ObSQLClientRetryWeak sql_client_retry_weak(sql_client,
exec_tenant_id,
sequence_table_id);
if (OB_ISNULL(mysql_proxy_)) {
ret = OB_NOT_INIT;
LOG_WARN("mysql proxy is null", K(ret));
} else if (sql_len >= OB_MAX_SQL_LENGTH || sql_len <= 0) {
ret = OB_SIZE_OVERFLOW;
LOG_WARN("failed to format sql. size not enough");
} else if (OB_FAIL(sql_client_retry_weak.read(res, exec_tenant_id, sql))) {
LOG_WARN(" failed to read data", K(ret));
} else if (NULL == (result = res.get_result())) {
LOG_WARN("failed to get result", K(ret));
ret = OB_ERR_UNEXPECTED;
} else if (OB_FAIL(result->next())) {
if (OB_ITER_END == ret) {
LOG_INFO("there is no autoinc column record, return 0 as seq_value by default",
K(key), K(ret));
seq_value = 0;
ret = OB_SUCCESS;
} else {
LOG_WARN("fail get next value", K(key), K(ret));
}
} else {
int64_t inner_autoinc_version = OB_INVALID_VERSION;
if (OB_FAIL(result->get_uint(0l, seq_value))) {
LOG_WARN("fail to get int_value.", K(ret));
} else if (OB_FAIL(result->get_uint(1l, sync_value))) {
LOG_WARN("fail to get int_value.", K(ret));
} else if (OB_FAIL(result->get_int(2l, inner_autoinc_version))) {
LOG_WARN("fail to get truncate_version.", K(ret));
} else if (OB_FAIL(check_inner_autoinc_version(tmp_autoinc_version, inner_autoinc_version, key))) {
LOG_WARN("fail to check inner_autoinc_version", KR(ret));
}
if (OB_SUCC(ret)) {
int tmp_ret = OB_SUCCESS;
if (OB_ITER_END != (tmp_ret = result->next())) {
if (OB_SUCCESS == tmp_ret) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("more than one row", K(ret), K(key));
} else {
ret = tmp_ret;
LOG_WARN("fail to iter next row", K(ret), K(key));
}
}
}
}
}
return ret;
}
// TODO: (xingrui.cwh)
// If this interface is used by another function except for __tenant_virtual_all_table,
// this interface will need to verfiy autoinc_version for correctness
int ObAutoIncInnerTableProxy::get_autoinc_value_in_batch(
const uint64_t tenant_id,
const common::ObIArray<AutoincKey> &keys,
common::hash::ObHashMap<AutoincKey, uint64_t> &seq_values)
{
int ret = OB_SUCCESS;
int64_t N = keys.count() / FETCH_SEQ_NUM_ONCE;
int64_t M = keys.count() % FETCH_SEQ_NUM_ONCE;
N += (M == 0) ? 0 : 1;
ObSqlString sql;
if (OB_ISNULL(mysql_proxy_)) {
ret = OB_NOT_INIT;
LOG_WARN("mysql proxy is null", K(ret));
}
for (int64_t i = 0; OB_SUCC(ret) && i < N; ++i) {
sql.reset();
if (OB_FAIL(sql.assign_fmt(
" SELECT sequence_key, column_id, sequence_value FROM %s"
" WHERE (sequence_key, column_id) IN (", OB_ALL_AUTO_INCREMENT_TNAME))) {
LOG_WARN("failed to append sql", K(ret));
}
// last iteration
int64_t P = (0 != M && N - 1 == i) ? M : FETCH_SEQ_NUM_ONCE;
for (int64_t j = 0; OB_SUCC(ret) && j < P; ++j) {
AutoincKey key = keys.at(i * FETCH_SEQ_NUM_ONCE + j);
if (OB_FAIL(sql.append_fmt("%s(%lu, %lu)",
(0 == j) ? "" : ", ",
key.table_id_,
key.column_id_))) {
LOG_WARN("failed to append sql", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(sql.append_fmt(")"))) {
LOG_WARN("failed to append sql", K(ret));
}
}
if (OB_SUCC(ret)) {
SMART_VAR(ObMySQLProxy::MySQLResult, res) {
ObMySQLResult *result = NULL;
int64_t table_id = 0;
int64_t column_id = 0;
uint64_t seq_value = 0;
ObISQLClient *sql_client = mysql_proxy_;
ObSQLClientRetryWeak sql_client_retry_weak(sql_client,
tenant_id,
OB_ALL_AUTO_INCREMENT_TID);
if (OB_FAIL(sql_client_retry_weak.read(res, tenant_id, sql.ptr()))) {
LOG_WARN(" failed to read data", K(ret));
} else if (NULL == (result = res.get_result())) {
LOG_WARN("failed to get result", K(ret));
ret = OB_ERR_UNEXPECTED;
} else {
while(OB_SUCC(ret) && OB_SUCC(result->next())) {
if (OB_FAIL(result->get_int(0l, table_id))) {
LOG_WARN("fail to get int_value.", K(ret));
} else if (OB_FAIL(result->get_int(1l, column_id))) {
LOG_WARN("fail to get int_value.", K(ret));
} else if (OB_FAIL(result->get_uint(2l, seq_value))) {
LOG_WARN("fail to get int_value.", K(ret));
} else {
AutoincKey key;
key.tenant_id_ = tenant_id;
key.table_id_ = table_id;
key.column_id_ = static_cast<uint64_t>(column_id);
if (OB_FAIL(seq_values.set_refactored(key, seq_value))) {
LOG_WARN("fail to get int_value.", K(ret));
}
}
}
if (OB_ITER_END == ret) {
ret = OB_SUCCESS;
} else {
LOG_WARN("fail to get next result", K(ret), K(sql));
}
}
}
}
if (OB_FAIL(ret)) {
break;
}
}
return ret;
}
int ObAutoIncInnerTableProxy::sync_autoinc_value(const AutoincKey &key,
const uint64_t insert_value,
const uint64_t max_value,
const int64_t autoinc_version,
uint64_t &seq_value,
uint64_t &sync_value)
{
int ret = OB_SUCCESS;
const uint64_t tenant_id = key.tenant_id_;
const uint64_t table_id = key.table_id_;
const uint64_t column_id = key.column_id_;
ObMySQLTransaction trans;
ObSqlString sql;
bool with_snap_shot = true;
uint64_t fetch_seq_value = 0;
int64_t inner_autoinc_version = OB_INVALID_VERSION;
int64_t tmp_autoinc_version = get_modify_autoinc_version(autoinc_version);
if (OB_ISNULL(mysql_proxy_)) {
ret = OB_NOT_INIT;
LOG_WARN("mysql proxy is null", K(ret));
} else if (OB_FAIL(trans.start(mysql_proxy_, tenant_id, with_snap_shot))) {
LOG_WARN("failed to start transaction", K(ret), K(tenant_id));
} else {
const uint64_t exec_tenant_id = tenant_id;
const char *table_name = OB_ALL_AUTO_INCREMENT_TNAME;
int64_t fetch_table_id = OB_INVALID_ID;
if (OB_FAIL(sql.assign_fmt(" SELECT sequence_key, sequence_value, sync_value, truncate_version FROM %s WHERE tenant_id = %lu AND sequence_key = %lu"
" AND column_id = %lu FOR UPDATE",
table_name,
ObSchemaUtils::get_extract_tenant_id(exec_tenant_id, tenant_id),
ObSchemaUtils::get_extract_schema_id(exec_tenant_id, table_id),
column_id))) {
LOG_WARN("failed to assign sql", K(ret));
}
if (OB_SUCC(ret)) {
SMART_VAR(ObMySQLProxy::MySQLResult, res) {
ObMySQLResult *result = NULL;
ObISQLClient *sql_client = &trans;
uint64_t sequence_table_id = OB_ALL_AUTO_INCREMENT_TID;
ObSQLClientRetryWeak sql_client_retry_weak(sql_client,
exec_tenant_id,
sequence_table_id);
if (OB_FAIL(sql_client_retry_weak.read(res, exec_tenant_id, sql.ptr()))) {
LOG_WARN("failed to read data", K(ret));
} else if (NULL == (result = res.get_result())) {
LOG_WARN("failed to get result", K(ret));
ret = OB_ERR_UNEXPECTED;
} else if (OB_FAIL(result->next())) {
LOG_WARN("failed to get next", K(ret));
if (OB_ITER_END == ret) {
// auto-increment column has been deleted
ret = OB_SCHEMA_ERROR;
LOG_WARN("failed to get next", K(ret));
}
} else if (OB_FAIL(result->get_int(0l, fetch_table_id))) {
LOG_WARN("failed to get int_value.", K(ret));
} else if (OB_FAIL(result->get_uint(1l, fetch_seq_value))) {
LOG_WARN("failed to get int_value.", K(ret));
} else if (OB_FAIL(result->get_uint(2l, sync_value))) {
LOG_WARN("failed to get int_value.", K(ret));
} else if (OB_FAIL(result->get_int(3l, inner_autoinc_version))) {
LOG_WARN("failed to get inner_autoinc_version.", K(ret));
} else if (OB_FAIL(check_inner_autoinc_version(tmp_autoinc_version, inner_autoinc_version, key))) {
LOG_WARN("failed to check inner_autoinc_version", KR(ret));
}
if (OB_SUCC(ret)) {
int tmp_ret = OB_SUCCESS;
if (OB_ITER_END != (tmp_ret = result->next())) {
if (OB_SUCCESS == tmp_ret) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("more than one row", K(ret), K(tenant_id), K(table_id), K(column_id));
} else {
ret = tmp_ret;
LOG_WARN("fail to iter next row", K(ret), K(tenant_id), K(table_id), K(column_id));
}
}
}
}
}
if (OB_SUCC(ret)) {
uint64_t new_seq_value = 0;
if (insert_value > sync_value) {
if (seq_value == 0) {
sync_value = std::max(fetch_seq_value - 1, insert_value);
new_seq_value = sync_value >= max_value ? max_value : sync_value + 1;
seq_value = new_seq_value;
} else {
// sequence value is vaild, use it to compute new sync/seq value
sync_value = std::max(seq_value - 1, insert_value);
new_seq_value = sync_value >= max_value ? max_value :
std::max(sync_value + 1, fetch_seq_value);
seq_value = sync_value >= max_value ? max_value : std::max(sync_value + 1, seq_value);
}
// if insert_value > global_sync
// 2. update __all_sequence(may get global_sync)
// 3. sync to other server
// 4. adjust cache_handle(prefetch) and table node
int64_t affected_rows = 0;
// NOTE: Why the sequence value is also updated?
// > In order to support display correct AUTO_INCREMENT property in SHOW CREATE TABLE
// statment.
// Why don't we calculate AUTO_INCREMENT in real time when we execute the SHOW
// statement?
// > I can't get MAX_VALUE in DDL context. auto inc column type is needed.
if (OB_FAIL(sql.assign_fmt(
"UPDATE %s SET sync_value = %lu, sequence_value = %lu, gmt_modified = now(6) "
"WHERE tenant_id=%lu AND sequence_key=%lu AND column_id=%lu AND truncate_version=%ld",
table_name, sync_value, new_seq_value,
OB_INVALID_TENANT_ID, table_id, column_id, inner_autoinc_version))) {
LOG_WARN("failed to assign sql", K(ret));
} else if (GCTX.is_standby_cluster() && OB_SYS_TENANT_ID != exec_tenant_id) {
ret = OB_OP_NOT_ALLOW;
LOG_WARN("can't write sys table now", K(ret), K(exec_tenant_id));
} else if (OB_FAIL((trans.write(exec_tenant_id, sql.ptr(), affected_rows)))) {
LOG_WARN("failed to execute", K(sql), K(ret));
} else if (!is_single_row(affected_rows)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected error", K(affected_rows), K(ret));
} else {
LOG_TRACE("sync insert value", K(key), K(insert_value));
}
// commit transaction or rollback
if (OB_SUCC(ret)) {
if (OB_FAIL(trans.end(true))) {
LOG_WARN("fail to commit transaction.", K(ret));
}
} else {
int err = OB_SUCCESS;
if (OB_SUCCESS != (err = trans.end(false))) {
LOG_WARN("fail to rollback transaction. ", K(err));
}
}
}
// if transactin is started above(but do nothing), end it here
if (trans.is_started()) {
if (OB_SUCC(ret)) {
if (OB_FAIL(trans.end(true))) {
LOG_WARN("fail to commit transaction.", K(ret));
}
} else {
int err = OB_SUCCESS;
if (OB_SUCCESS != (err = trans.end(false))) {
LOG_WARN("fail to rollback transaction. ", K(err));
}
}
}
}
}
return ret;
}
}//end namespace share
}//end namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink