hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

init push

Browse Source
This commit is contained in:
oceanbase-admin
2021-05-31 22:56:52 +08:00
commit cea7de1475
7020 changed files with 5689869 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

361
src/share/ob_dml_sql_splicer.h Normal file
View File

@ -0,0 +1,361 @@
/**
* 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_SHARE_OB_DML_SQL_SPLICER_H_
#define OCEANBASE_SHARE_OB_DML_SQL_SPLICER_H_
#include "lib/string/ob_sql_string.h"
#include "lib/container/ob_se_array.h"
#include "share/ob_core_table_proxy.h"
namespace oceanbase {
namespace common {
class ObISQLClient;
class ObHexEscapeSqlStr;
namespace number {
class ObNumber;
}
} // namespace common
namespace share {
struct ObPartitionReplica;
// Splice dml sql, e.g: INSERT INTO, INSERT INTO ... ON DUPLICATE KEY UPDATE, REPLACE, UPDATE
//
// USAGE:
// ObDMLSqlSplicer dml_splider;
// if (OB_FAIL(dml_splider.add_pk_column("col1", 1))
// || OB_FAIL(dml_splicer.add_pk_column("col2", 2))
// || OB_FAIL(dml_splicer..add_column("col3", "str3"))) {
// // log ....
// }
// ObSqString sql;
//
// // result: INSERT INTO tname (col1, col2, col3) VALUES (1, 2, 'str3')
// ret = dml_splicer.splice_insert_sql("tname", sql);
//
// // result: INSERT INTO tname (col1, col2, col3) VALUES (1, 2, 'str3')
// // ON DUPLICATE KEY UPDATE col3 = 'str3'
// ret = dml_splicer.splice_insert_update_sql("tname", sql);
//
// // result: UPDATE tname SET col3 = 'str3' WHERE col1 = 1 AND col2 = 2
// ret = dml_splicer.splice_update_sql("tname", sql);
//
class ObRealUInt64 {
public:
ObRealUInt64(const uint64_t v) : v_(v)
{}
uint64_t value() const
{
return v_;
}
TO_STRING_KV(K_(v));
private:
uint64_t v_;
};
class ObDMLSqlSplicer {
public:
friend class ObPTSqlSplicer;
// for columns with NULL value
static const char* const NULL_VALUE;
static const int64_t MAX_TO_STRING_BUF_SIZE = common::MAX_ROOTSERVICE_EVENT_EXTRA_INFO_LENGTH;
static const int64_t DEF_COLUMN_CNT = 64;
enum Mode {
QUOTE_STRING_MODE, // add quote string to string value
NAKED_VALUE_MODE, // don't quote string
};
explicit ObDMLSqlSplicer(Mode mode = QUOTE_STRING_MODE) : mode_(mode), is_hex_value_(false)
{}
virtual ~ObDMLSqlSplicer()
{}
void reset();
void reuse()
{
reset();
}
// add columns. (NOTE: only int and string values supported right now)
template <typename T>
int add_column(const char* col_name, const T& value);
template <typename T>
int add_pk_column(const char* col_name, const T& value);
int add_gmt_modified(const int64_t now = -1)
{
return add_time_column("gmt_modified", now);
}
int add_gmt_create(const int64_t now = -1)
{
return add_time_column("gmt_create", now);
}
common::ObSqlString& get_extra_condition()
{
return extra_condition_;
}
// Append value to values_, then add column with only %col_name.
// NOTE: caller must known how ObDMLSqlSplicer works.
common::ObSqlString& get_values()
{
return values_;
}
int add_pk_column(const bool is_null, const char* col_name);
int add_column(const bool is_null, const char* col_name);
int add_time_column(const char* col_name, const int64_t now);
int add_raw_time_column(const char* col_name, const int64_t now);
// mark end of one row
int finish_row();
/// functions to splice sql string:
int splice_insert_sql(const char* table_name, common::ObSqlString& sql) const;
int splice_insert_sql_without_plancache(const char* table_name, common::ObSqlString& sql) const;
int splice_insert_ignore_sql(const char* table_name, common::ObSqlString& sql) const;
int splice_insert_update_sql(const char* table_name, common::ObSqlString& sql) const;
int splice_replace_sql(const char* table_name, common::ObSqlString& sql) const;
int splice_update_sql(const char* table_name, common::ObSqlString& sql) const;
int splice_delete_sql(const char* table_name, common::ObSqlString& sql) const;
// "pk1, pk2, c3, c4"
int splice_column_names(common::ObSqlString& sql) const;
// "v1, v2, v3, v4"
int splice_values(common::ObSqlString& sql) const;
// "pk1=v1 AND pk2=v2 AND c3=v3 AND c4=v4"
int splice_predicates(common::ObSqlString& sql) const;
// "SELECT 1 FROM %table_name WHERE pk1 = value1 AND pk2 = value2 ..."
int splice_select_1_sql(const char* table_name, common::ObSqlString& sql) const;
int splice_core_cells(ObCoreTableProxy& kv_proxy, common::ObIArray<ObCoreTableProxy::UpdateCell>& cells);
// functions to splice batch sql statement
int splice_batch_insert_sql(const char* table_name, common::ObSqlString& sql) const;
int splice_batch_insert_update_sql(const char* table_name, common::ObSqlString& sql) const;
int splice_batch_replace_sql_without_plancache(const char* table_name, common::ObSqlString& sql) const;
int splice_batch_replace_sql(const char* table_name, common::ObSqlString& sql) const;
int splice_batch_delete_sql(const char* table_name, common::ObSqlString& sql) const;
// "(c1, c2, c3) IN ((v11, v12, v13), (v21, v22, v23))"
int splice_batch_predicates_sql(common::ObSqlString& sql) const;
private:
struct Column {
const char* name_;
// end position of %ObDMLSqlSplicer::values_
int64_t value_end_pos_;
bool primary_key_;
bool is_null_;
bool is_hex_value_;
TO_STRING_KV(K_(primary_key), K_(is_null), K_(name), K_(value_end_pos));
Column() : name_(NULL), value_end_pos_(0), primary_key_(false), is_null_(false), is_hex_value_(false)
{}
};
struct ColSet {
enum Type {
ALL,
ONLY_PK,
FILTER_PK,
};
};
struct ValSet {
enum Type {
ALL,
ONLY_COL_NAME,
ONLY_VALUE,
};
};
// splice columns to sql, e.g:
// col_name, col_name, col_name
// value, value, value
// col_name = value, col_name = value, col_name = value
// col_name = value AND col_name = value AND col_name = value
int splice_column(
const char* sep, const ColSet::Type col_set, const ValSet::Type val_set, common::ObSqlString& sql) const;
int append_value(const uint64_t value, bool& is_null);
int append_value(const int64_t value, bool& is_null);
int append_value(const uint32_t value, bool& is_null);
int append_value(const int32_t value, bool& is_null);
int append_value(const uint16_t value, bool& is_null);
int append_value(const int16_t value, bool& is_null);
int append_value(const uint8_t value, bool& is_null);
int append_value(const int8_t value, bool& is_null);
int append_value(const bool value, bool& is_null);
int append_value(const double value, bool& is_null);
int append_value(const char* str, bool& is_null);
int append_value(char* str, bool& is_null);
int append_value(const common::number::ObNumber& nmb, bool& is_null);
int append_value(const common::ObString& str, bool& is_null);
int append_value(const common::ObHexEscapeSqlStr& escape_str, bool& is_null);
int append_value(const ObRealUInt64& value, bool& is_null);
int append_value(const common::ObObj& obj, bool& is_null);
template <typename T>
int append_value(const T& obj, bool& is_null, common::FalseType);
template <typename T>
int append_value(const T& obj, bool& is_null, common::TrueType);
template <typename T>
int append_value(const T& obj, bool& is_null);
template <typename T>
int add_column(const bool is_primary_key, const char* col_name, const T& value);
int add_column(const bool is_primary_key, const bool is_null, const char* col_name);
int splice_insert(const char* table_name, const char* head, common::ObSqlString& sql) const;
int build_rows_matrix(common::ObIArray<common::ObString>& all_names, common::ObIArray<int64_t>& rows_matrix) const;
int splice_rows_matrix(const common::ObArray<common::ObString>& all_names,
const common::ObArray<int64_t>& rows_matrix, common::ObSqlString& sql) const;
int splice_batch_insert(const char* table_name, const char* head, common::ObSqlString& sql,
common::ObArray<common::ObString>& all_names, common::ObArray<int64_t>& rows_matrix) const;
int splice_batch_predicates(const common::ObArray<common::ObString>& all_names,
const common::ObArray<int64_t>& rows_matrix, common::ObSqlString& sql) const;
private:
Mode mode_;
common::ObSqlString values_;
common::ObSEArray<Column, DEF_COLUMN_CNT> columns_;
// additional condition for update sql
common::ObSqlString extra_condition_;
// mark value string is hex
bool is_hex_value_;
common::ObSEArray<int64_t, DEF_COLUMN_CNT> rows_end_pos_;
DISALLOW_COPY_AND_ASSIGN(ObDMLSqlSplicer);
};
class ObPTSqlSplicer : public ObDMLSqlSplicer {
public:
ObPTSqlSplicer()
{}
~ObPTSqlSplicer()
{}
int splice_update_leader_replica_sql(
const ObPartitionReplica& replica, const char* table_name, common::ObSqlString& sql) const;
int splice_batch_insert_update_replica_sql(
const char* table_name, const bool with_role, common::ObSqlString& sql) const;
int splice_insert_update_replica_sql(const char* table_name, common::ObSqlString& sql) const;
private:
int splice_batch_insert_update_replica_column(const bool with_role, const common::ObString& sep,
const common::ObIArray<common::ObString>& names, common::ObSqlString& sql) const;
int splice_insert_update_replica_column(const char* sep, common::ObSqlString& sql) const;
};
#define OBJ_K(obj, name) #name, (obj).name##_
#define OBJ_GET_K(obj, name) #name, (obj).get_##name()
// help execute dml sql
class ObDMLExecHelper {
public:
friend class ObNormalPartitionUpdateHelper;
ObDMLExecHelper(common::ObISQLClient& sql_client, const uint64_t tenant_id)
: tenant_id_(tenant_id), sql_client_(sql_client)
{}
virtual ~ObDMLExecHelper()
{}
int exec_insert(const char* table_name, const ObDMLSqlSplicer& splicer, int64_t& affected_rows);
int exec_insert_ignore(const char* table_name, const ObDMLSqlSplicer& splicer, int64_t& affected_rows);
int exec_insert_update(const char* table_name, const ObDMLSqlSplicer& splicer, int64_t& affected_rows);
int exec_replace(const char* table_name, const ObDMLSqlSplicer& splicer, int64_t& affected_rows);
int exec_update(const char* table_name, const ObDMLSqlSplicer& splicer, int64_t& affected_rows);
int exec_delete(const char* table_name, const ObDMLSqlSplicer& splicer, int64_t& affected_rows);
private:
int check_row_exist(const char* table_name, const ObDMLSqlSplicer& splicer, bool& exist);
uint64_t tenant_id_;
common::ObISQLClient& sql_client_;
};
template <typename T>
int ObDMLSqlSplicer::append_value(const T& obj, bool& is_null, common::FalseType)
{
int ret = common::OB_SUCCESS;
char buf[MAX_TO_STRING_BUF_SIZE];
int64_t pos = 0;
if (0 > (pos = obj.to_string(buf, MAX_TO_STRING_BUF_SIZE)) || pos >= MAX_TO_STRING_BUF_SIZE) {
ret = common::OB_BUF_NOT_ENOUGH;
SHARE_LOG(WARN, "obj to_string failed", K(pos), K(ret));
} else {
if (0 == pos) {
is_null = true;
} else {
is_null = false;
if (OB_FAIL(values_.append_fmt(mode_ == NAKED_VALUE_MODE ? "%.*s" : "'%.*s'", static_cast<int32_t>(pos), buf))) {
SHARE_LOG(WARN, "append value failed", K(pos), K(ret));
}
}
}
return ret;
}
template <typename T>
int ObDMLSqlSplicer::append_value(const T& obj, bool& is_null, common::TrueType)
{
is_null = false;
return values_.append_fmt("%ld", static_cast<int64_t>(obj));
}
template <typename T>
int ObDMLSqlSplicer::append_value(const T& obj, bool& is_null)
{
return append_value(obj, is_null, common::BoolType<__is_enum(T)>());
}
template <typename T>
int ObDMLSqlSplicer::add_column(const char* col_name, const T& value)
{
const bool is_pk = false;
int ret = common::OB_SUCCESS;
if (OB_ISNULL(col_name)) {
ret = common::OB_INVALID_ARGUMENT;
SHARE_LOG(WARN, "invalid column name", K(ret), KP(col_name));
} else if (OB_FAIL(add_column(is_pk, col_name, value))) {
SHARE_LOG(WARN, "add column failed", K(ret), K(is_pk), K(col_name), K(value));
}
return ret;
}
template <typename T>
int ObDMLSqlSplicer::add_pk_column(const char* col_name, const T& value)
{
const bool is_pk = true;
int ret = common::OB_SUCCESS;
if (OB_ISNULL(col_name)) {
ret = common::OB_INVALID_ARGUMENT;
SHARE_LOG(WARN, "invalid column name", K(ret), KP(col_name));
} else if (OB_FAIL(add_column(is_pk, col_name, value))) {
SHARE_LOG(WARN, "add column failed", K(ret), K(is_pk), K(col_name), K(value));
}
return ret;
}
template <typename T>
int ObDMLSqlSplicer::add_column(const bool is_primary_key, const char* col_name, const T& value)
{
bool is_null = false;
int ret = common::OB_SUCCESS;
if (OB_ISNULL(col_name)) {
ret = common::OB_INVALID_ARGUMENT;
SHARE_LOG(WARN, "invalid column name", K(ret), KP(col_name));
} else if (OB_FAIL(append_value(value, is_null))) {
SHARE_LOG(WARN, "append value failed", K(ret), K(value));
} else if (OB_FAIL(add_column(is_primary_key, is_null, col_name))) {
SHARE_LOG(WARN, "add column failed", K(ret));
}
return ret;
}
} // end namespace share
} // end namespace oceanbase
#endif // OCEANBASE_SHARE_OB_DML_SQL_SPLICER_H_