database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-12-04 17:23:46 +03:00
Code Activity

refs #5081 Replace all usage:

Browse Source 
BOOL->bool
FALSE->false
TRUE->true
u_int*_t->uint*_t

Also poisoned all of the variables

git-svn-id: file:///svn/mysql/tokudb-engine/tokudb-engine@46156 c7de825b-a66e-492c-adef-691d508d4ae1
This commit is contained in:
Yoni Fogel
2013-04-17 00:02:13 -04:00
parent 16f359b73e
commit 274b25eb8b
11 changed files with 651 additions and 651 deletions
Download Patch File Download Diff File Expand all files Collapse all files

288
storage/tokudb/ha_tokudb.cc
View File

@@ -79,7 +79,7 @@ static void share_key_file_unlock(TOKUDB_SHARE * share)
//
// This offset is calculated starting from AFTER the NULL bytes
//
static inline u_int32_t get_fixed_field_size(KEY_AND_COL_INFO* kc_info, TABLE_SHARE* table_share, uint keynr) {
static inline uint32_t get_fixed_field_size(KEY_AND_COL_INFO* kc_info, TABLE_SHARE* table_share, uint keynr) {
uint offset = 0;
for (uint i = 0; i < table_share->fields; i++) {
if (kc_info->field_lengths[i] && !bitmap_is_set(&kc_info->key_filters[keynr],i)) {
@@ -90,7 +90,7 @@ static inline u_int32_t get_fixed_field_size(KEY_AND_COL_INFO* kc_info, TABLE_SH
}
static inline u_int32_t get_len_of_offsets(KEY_AND_COL_INFO* kc_info, TABLE_SHARE* table_share, uint keynr) {
static inline uint32_t get_len_of_offsets(KEY_AND_COL_INFO* kc_info, TABLE_SHARE* table_share, uint keynr) {
uint len = 0;
for (uint i = 0; i < table_share->fields; i++) {
if (kc_info->length_bytes[i] && !bitmap_is_set(&kc_info->key_filters[keynr],i)) {
@@ -121,9 +121,9 @@ static int allocate_key_and_col_info ( TABLE_SHARE* table_share, KEY_AND_COL_INF
//
// create the field lengths
//
kc_info->field_lengths = (u_int16_t *)my_malloc(table_share->fields*sizeof(u_int16_t), MYF(MY_WME | MY_ZEROFILL));
kc_info->field_lengths = (uint16_t *)my_malloc(table_share->fields*sizeof(uint16_t), MYF(MY_WME | MY_ZEROFILL));
kc_info->length_bytes= (uchar *)my_malloc(table_share->fields, MYF(MY_WME | MY_ZEROFILL));
kc_info->blob_fields= (u_int32_t *)my_malloc(table_share->fields*sizeof(u_int32_t), MYF(MY_WME | MY_ZEROFILL));
kc_info->blob_fields= (uint32_t *)my_malloc(table_share->fields*sizeof(uint32_t), MYF(MY_WME | MY_ZEROFILL));
if (kc_info->field_lengths == NULL ||
kc_info->length_bytes == NULL ||
@@ -636,7 +636,7 @@ static inline HA_TOKU_ISO_LEVEL tx_to_toku_iso(ulong tx_isolation) {
}
}
static inline u_int32_t toku_iso_to_txn_flag (HA_TOKU_ISO_LEVEL lvl) {
static inline uint32_t toku_iso_to_txn_flag (HA_TOKU_ISO_LEVEL lvl) {
if (lvl == hatoku_iso_read_uncommitted) {
return DB_READ_UNCOMMITTED;
}
@@ -724,7 +724,7 @@ void set_key_filter(MY_BITMAP* key_filter, KEY* key, TABLE* table, bool get_offs
static inline uchar* pack_fixed_field(
uchar* to_tokudb,
const uchar* from_mysql,
u_int32_t num_bytes
uint32_t num_bytes
)
{
switch (num_bytes) {
@@ -753,7 +753,7 @@ static inline uchar* pack_fixed_field(
static inline const uchar* unpack_fixed_field(
uchar* to_mysql,
const uchar* from_tokudb,
u_int32_t num_bytes
uint32_t num_bytes
)
{
switch (num_bytes) {
@@ -784,15 +784,15 @@ static inline uchar* write_var_field(
uchar* to_tokudb_data, // location where data is going to be written
uchar* to_tokudb_offset_start, //location where offset starts, IS THIS A BAD NAME????
const uchar * data, // the data to write
u_int32_t data_length, // length of data to write
u_int32_t offset_bytes // number of offset bytes
uint32_t data_length, // length of data to write
uint32_t offset_bytes // number of offset bytes
)
{
memcpy(to_tokudb_data, data, data_length);
//
// for offset, we pack the offset where the data ENDS!
//
u_int32_t offset = to_tokudb_data + data_length - to_tokudb_offset_start;
uint32_t offset = to_tokudb_data + data_length - to_tokudb_offset_start;
switch(offset_bytes) {
case (1):
to_tokudb_offset_ptr[0] = (uchar)offset;
@@ -807,12 +807,12 @@ static inline uchar* write_var_field(
return to_tokudb_data + data_length;
}
static inline u_int32_t get_var_data_length(
static inline uint32_t get_var_data_length(
const uchar * from_mysql,
u_int32_t mysql_length_bytes
uint32_t mysql_length_bytes
)
{
u_int32_t data_length;
uint32_t data_length;
switch(mysql_length_bytes) {
case(1):
data_length = from_mysql[0];
@@ -832,8 +832,8 @@ static inline uchar* pack_var_field(
uchar* to_tokudb_data, // pointer to where tokudb data should be written
uchar* to_tokudb_offset_start, //location where data starts, IS THIS A BAD NAME????
const uchar * from_mysql, // mysql data
u_int32_t mysql_length_bytes, //number of bytes used to store length in from_mysql
u_int32_t offset_bytes //number of offset_bytes used in tokudb row
uint32_t mysql_length_bytes, //number of bytes used to store length in from_mysql
uint32_t offset_bytes //number of offset_bytes used in tokudb row
)
{
uint data_length = get_var_data_length(from_mysql, mysql_length_bytes);
@@ -850,8 +850,8 @@ static inline uchar* pack_var_field(
static inline void unpack_var_field(
uchar* to_mysql,
const uchar* from_tokudb_data,
u_int32_t from_tokudb_data_len,
u_int32_t mysql_length_bytes
uint32_t from_tokudb_data_len,
uint32_t mysql_length_bytes
)
{
//
@@ -880,14 +880,14 @@ static uchar* pack_toku_field_blob(
Field* field
)
{
u_int32_t len_bytes = field->row_pack_length();
u_int32_t length = 0;
uint32_t len_bytes = field->row_pack_length();
uint32_t length = 0;
uchar* data_ptr = NULL;
memcpy(to_tokudb, from_mysql, len_bytes);
switch (len_bytes) {
case (1):
length = (u_int32_t)(*from_mysql);
length = (uint32_t)(*from_mysql);
break;
case (2):
length = uint2korr(from_mysql);
@@ -1067,13 +1067,13 @@ static inline int tokudb_generate_row(
DB* curr_db = dest_db;
uchar* row_desc = NULL;
u_int32_t desc_size;
uint32_t desc_size;
uchar* buff = NULL;
u_int32_t max_key_len = 0;
uint32_t max_key_len = 0;
row_desc = (uchar *)curr_db->descriptor->dbt.data;
row_desc += (*(u_int32_t *)row_desc);
desc_size = (*(u_int32_t *)row_desc) - 4;
row_desc += (*(uint32_t *)row_desc);
desc_size = (*(uint32_t *)row_desc) - 4;
row_desc += 4;
if (is_key_pk(row_desc, desc_size)) {
@@ -1141,7 +1141,7 @@ static inline int tokudb_generate_row(
}
row_desc += desc_size;
desc_size = (*(u_int32_t *)row_desc) - 4;
desc_size = (*(uint32_t *)row_desc) - 4;
row_desc += 4;
if (dest_val != NULL) {
if (!is_key_clustering(row_desc, desc_size) || src_val->size == 0) {
@@ -1257,7 +1257,7 @@ ha_tokudb::ha_tokudb(handlerton * hton, TABLE_SHARE * table_arg):handler(hton, t
abort_loader = false;
memset(&lc, 0, sizeof(lc));
lock.type = TL_IGNORE;
for (u_int32_t i = 0; i < MAX_KEY+1; i++) {
for (uint32_t i = 0; i < MAX_KEY+1; i++) {
mult_put_flags[i] = 0;
mult_del_flags[i] = DB_DELETE_ANY;
mult_dbt_flags[i] = DB_DBT_REALLOC;
@@ -1307,7 +1307,7 @@ static int open_status_dictionary(DB** ptr, const char* name, DB_TXN* txn) {
int error;
char* newname = NULL;
uint open_mode = DB_THREAD;
u_int32_t pagesize = 0;
uint32_t pagesize = 0;
newname = (char *)my_malloc(
get_max_dict_name_path_length(name),
MYF(MY_WME)
@@ -1461,8 +1461,8 @@ static int initialize_col_pack_info(KEY_AND_COL_INFO* kc_info, TABLE_SHARE* tabl
goto exit;
}
{
u_int32_t curr_fixed_offset = 0;
u_int32_t curr_var_index = 0;
uint32_t curr_fixed_offset = 0;
uint32_t curr_var_index = 0;
for (uint j = 0; j < table_share->fields; j++) {
COL_PACK_INFO* curr = &kc_info->cp_info[keynr][j];
//
@@ -1511,8 +1511,8 @@ static void reset_key_and_col_info(KEY_AND_COL_INFO *kc_info, uint keynr) {
static int initialize_key_and_col_info(TABLE_SHARE* table_share, TABLE* table, KEY_AND_COL_INFO* kc_info, uint hidden_primary_key, uint primary_key) {
int error = 0;
u_int32_t curr_blob_field_index = 0;
u_int32_t max_var_bytes = 0;
uint32_t curr_blob_field_index = 0;
uint32_t max_var_bytes = 0;
//
// fill in the field lengths. 0 means it is a variable sized field length
// fill in length_bytes, 0 means it is fixed or blob
@@ -1529,7 +1529,7 @@ static int initialize_key_and_col_info(TABLE_SHARE* table_share, TABLE* table, K
case toku_type_fixstring:
pack_length = field->pack_length();
assert(pack_length < 1<<16);
kc_info->field_lengths[i] = (u_int16_t)pack_length;
kc_info->field_lengths[i] = (uint16_t)pack_length;
kc_info->length_bytes[i] = 0;
break;
case toku_type_blob:
@@ -1643,7 +1643,7 @@ int ha_tokudb::initialize_share(
)
{
int error = 0;
u_int64_t num_rows = 0;
uint64_t num_rows = 0;
bool table_exists;
DB_TXN* txn = NULL;
bool do_commit = false;
@@ -1734,7 +1734,7 @@ int ha_tokudb::initialize_share(
// We need to set the ref_length to start at 5, to account for
// the "infinity byte" in keys, and for placing the DBT size in the first four bytes
//
ref_length = sizeof(u_int32_t) + sizeof(uchar);
ref_length = sizeof(uint32_t) + sizeof(uchar);
KEY_PART_INFO *key_part = table->key_info[primary_key].key_part;
KEY_PART_INFO *end = key_part + table->key_info[primary_key].key_parts;
for (; key_part != end; key_part++) {
@@ -1811,7 +1811,7 @@ int ha_tokudb::open(const char *name, int mode, uint test_if_locked) {
primary_key = table_share->keys;
key_used_on_scan = MAX_KEY;
hidden_primary_key = TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH;
ref_length = TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH + sizeof(u_int32_t);
ref_length = TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH + sizeof(uint32_t);
}
else {
key_used_on_scan = primary_key;
@@ -1829,8 +1829,8 @@ int ha_tokudb::open(const char *name, int mode, uint test_if_locked) {
&prelocked_left_range, max_key_length,
&prelocked_right_range, max_key_length,
&primary_key_buff, (hidden_primary_key ? 0 : max_key_length),
&fixed_cols_for_query, table_share->fields*sizeof(u_int32_t),
&var_cols_for_query, table_share->fields*sizeof(u_int32_t),
&fixed_cols_for_query, table_share->fields*sizeof(uint32_t),
&var_cols_for_query, table_share->fields*sizeof(uint32_t),
NullS
);
if (alloc_ptr == NULL) {
@@ -1859,11 +1859,11 @@ int ha_tokudb::open(const char *name, int mode, uint test_if_locked) {
goto exit;
}
for (u_int32_t i = 0; i < sizeof(mult_key_dbt)/sizeof(mult_key_dbt[0]); i++) {
for (uint32_t i = 0; i < sizeof(mult_key_dbt)/sizeof(mult_key_dbt[0]); i++) {
mult_key_dbt[i].flags = DB_DBT_REALLOC;
}
for (u_int32_t i = 0; i < curr_num_DBs; i++) {
for (uint32_t i = 0; i < curr_num_DBs; i++) {
mult_rec_dbt[i].flags = DB_DBT_REALLOC;
}
@@ -1929,7 +1929,7 @@ exit:
// 0 on success
// error otherwise
//
int ha_tokudb::estimate_num_rows(DB* db, u_int64_t* num_rows, DB_TXN* txn) {
int ha_tokudb::estimate_num_rows(DB* db, uint64_t* num_rows, DB_TXN* txn) {
int error = ENOSYS;
DBC* crsr = NULL;
bool do_commit = false;
@@ -2193,13 +2193,13 @@ int ha_tokudb::__close(int mutex_is_locked) {
my_free(blob_buff, MYF(MY_ALLOW_ZERO_PTR));
my_free(alloc_ptr, MYF(MY_ALLOW_ZERO_PTR));
my_free(range_query_buff, MYF(MY_ALLOW_ZERO_PTR));
for (u_int32_t i = 0; i < sizeof(mult_rec_dbt)/sizeof(mult_rec_dbt[0]); i++) {
for (uint32_t i = 0; i < sizeof(mult_rec_dbt)/sizeof(mult_rec_dbt[0]); i++) {
if (mult_rec_dbt[i].flags == DB_DBT_REALLOC &&
mult_rec_dbt[i].data != NULL) {
free(mult_rec_dbt[i].data);
}
}
for (u_int32_t i = 0; i < sizeof(mult_key_dbt)/sizeof(mult_key_dbt[0]); i++) {
for (uint32_t i = 0; i < sizeof(mult_key_dbt)/sizeof(mult_key_dbt[0]); i++) {
if (mult_key_dbt[i].flags == DB_DBT_REALLOC &&
mult_key_dbt[i].data != NULL) {
free(mult_key_dbt[i].data);
@@ -2366,7 +2366,7 @@ int ha_tokudb::pack_old_row_for_update(
int ha_tokudb::unpack_blobs(
uchar* record,
const uchar* from_tokudb_blob,
u_int32_t num_bytes,
uint32_t num_bytes,
bool check_bitmap
)
{
@@ -2390,13 +2390,13 @@ int ha_tokudb::unpack_blobs(
memcpy(blob_buff, from_tokudb_blob, num_bytes);
buff= blob_buff;
for (uint i = 0; i < share->kc_info.num_blobs; i++) {
u_int32_t curr_field_index = share->kc_info.blob_fields[i];
uint32_t curr_field_index = share->kc_info.blob_fields[i];
bool skip = check_bitmap ?
!(bitmap_is_set(table->read_set,curr_field_index) ||
bitmap_is_set(table->write_set,curr_field_index)) :
false;
Field* field = table->field[curr_field_index];
u_int32_t len_bytes = field->row_pack_length();
uint32_t len_bytes = field->row_pack_length();
buff = unpack_toku_field_blob(
record + field_offset(field, table),
buff,
@@ -2432,7 +2432,7 @@ int ha_tokudb::unpack_row(
const uchar* fixed_field_ptr = (const uchar *) row->data;
const uchar* var_field_offset_ptr = NULL;
const uchar* var_field_data_ptr = NULL;
u_int32_t data_end_offset = 0;
uint32_t data_end_offset = 0;
memcpy(record, fixed_field_ptr, table_share->null_bytes);
fixed_field_ptr += table_share->null_bytes;
@@ -2446,7 +2446,7 @@ int ha_tokudb::unpack_row(
unpack_key(record,key,index);
}
u_int32_t last_offset = 0;
uint32_t last_offset = 0;
//
// we have two methods of unpacking, one if we need to unpack the entire row
// the second if we unpack a subset of the entire row
@@ -2499,7 +2499,7 @@ int ha_tokudb::unpack_row(
error = unpack_blobs(
record,
var_field_data_ptr,
row->size - (u_int32_t)(var_field_data_ptr - (const uchar *)row->data),
row->size - (uint32_t)(var_field_data_ptr - (const uchar *)row->data),
false
);
if (error) {
@@ -2514,7 +2514,7 @@ int ha_tokudb::unpack_row(
//
// first the fixed fields
//
for (u_int32_t i = 0; i < num_fixed_cols_for_query; i++) {
for (uint32_t i = 0; i < num_fixed_cols_for_query; i++) {
uint field_index = fixed_cols_for_query[i];
Field* field = table->field[field_index];
unpack_fixed_field(
@@ -2528,12 +2528,12 @@ int ha_tokudb::unpack_row(
// now the var fields
// here, we do NOT modify var_field_data_ptr or var_field_offset_ptr
//
for (u_int32_t i = 0; i < num_var_cols_for_query; i++) {
for (uint32_t i = 0; i < num_var_cols_for_query; i++) {
uint field_index = var_cols_for_query[i];
Field* field = table->field[field_index];
u_int32_t var_field_index = share->kc_info.cp_info[index][field_index].col_pack_val;
u_int32_t data_start_offset;
u_int32_t field_len;
uint32_t var_field_index = share->kc_info.cp_info[index][field_index].col_pack_val;
uint32_t data_start_offset;
uint32_t field_len;
get_var_field_info(
&field_len,
@@ -2566,7 +2566,7 @@ int ha_tokudb::unpack_row(
error = unpack_blobs(
record,
var_field_data_ptr,
row->size - (u_int32_t)(var_field_data_ptr - (const uchar *)row->data),
row->size - (uint32_t)(var_field_data_ptr - (const uchar *)row->data),
true
);
if (error) {
@@ -2579,7 +2579,7 @@ exit:
return error;
}
u_int32_t ha_tokudb::place_key_into_mysql_buff(
uint32_t ha_tokudb::place_key_into_mysql_buff(
KEY* key_info,
uchar * record,
uchar* data
@@ -2626,7 +2626,7 @@ u_int32_t ha_tokudb::place_key_into_mysql_buff(
// unpacking a key of
//
void ha_tokudb::unpack_key(uchar * record, DBT const *key, uint index) {
u_int32_t bytes_read;
uint32_t bytes_read;
uchar *pos = (uchar *) key->data + 1;
bytes_read = place_key_into_mysql_buff(
&table->key_info[index],
@@ -2645,7 +2645,7 @@ void ha_tokudb::unpack_key(uchar * record, DBT const *key, uint index) {
}
}
u_int32_t ha_tokudb::place_key_into_dbt_buff(
uint32_t ha_tokudb::place_key_into_dbt_buff(
KEY* key_info,
uchar * buff,
const uchar * record,
@@ -2721,7 +2721,7 @@ DBT* ha_tokudb::create_dbt_key_from_key(
int key_length
)
{
u_int32_t size = 0;
uint32_t size = 0;
uchar* tmp_buff = buff;
my_bitmap_map *old_map = dbug_tmp_use_all_columns(table, table->write_set);
@@ -3065,12 +3065,12 @@ ha_rows ha_tokudb::estimate_rows_upper_bound() {
int ha_tokudb::cmp_ref(const uchar * ref1, const uchar * ref2) {
int ret_val = 0;
ret_val = tokudb_compare_two_keys(
ref1 + sizeof(u_int32_t),
*(u_int32_t *)ref1,
ref2 + sizeof(u_int32_t),
*(u_int32_t *)ref2,
ref1 + sizeof(uint32_t),
*(uint32_t *)ref1,
ref2 + sizeof(uint32_t),
*(uint32_t *)ref2,
(uchar *)share->file->descriptor->dbt.data + 4,
*(u_int32_t *)share->file->descriptor->dbt.data - 4,
*(uint32_t *)share->file->descriptor->dbt.data - 4,
false
);
return ret_val;
@@ -3173,7 +3173,7 @@ void ha_tokudb::start_bulk_insert(ha_rows rows) {
if (!thd_test_options(thd, OPTION_RELAXED_UNIQUE_CHECKS) && !hidden_primary_key) {
mult_put_flags[primary_key] = DB_NOOVERWRITE;
}
u_int32_t loader_flags = (get_load_save_space(thd)) ?
uint32_t loader_flags = (get_load_save_space(thd)) ?
LOADER_USE_PUTS : 0;
int error = db_env->create_loader(
@@ -3307,7 +3307,7 @@ int ha_tokudb::is_index_unique(bool* is_unique, DB_TXN* txn, DB* db, KEY* key_in
DBC* tmp_cursor1 = NULL;
DBC* tmp_cursor2 = NULL;
DBT key1, key2, val, packed_key1, packed_key2;
u_int64_t cnt = 0;
uint64_t cnt = 0;
char status_msg[MAX_ALIAS_NAME + 200]; //buffer of 200 should be a good upper bound.
THD* thd = ha_thd();
memset(&key1, 0, sizeof(key1));
@@ -3594,9 +3594,9 @@ void ha_tokudb::test_row_packing(uchar* record, DBT* pk_key, DBT* pk_val) {
tmp_pk_val.size = pk_val->size;
for (uint keynr = 0; keynr < table_share->keys; keynr++) {
u_int32_t tmp_num_bytes = 0;
uint32_t tmp_num_bytes = 0;
uchar* row_desc = NULL;
u_int32_t desc_size = 0;
uint32_t desc_size = 0;
if (keynr == primary_key) {
continue;
@@ -3608,8 +3608,8 @@ void ha_tokudb::test_row_packing(uchar* record, DBT* pk_key, DBT* pk_val) {
// TEST
//
row_desc = (uchar *)share->key_file[keynr]->descriptor->dbt.data;
row_desc += (*(u_int32_t *)row_desc);
desc_size = (*(u_int32_t *)row_desc) - 4;
row_desc += (*(uint32_t *)row_desc);
desc_size = (*(uint32_t *)row_desc) - 4;
row_desc += 4;
tmp_num_bytes = pack_key_from_desc(
key_buff3,
@@ -3632,9 +3632,9 @@ void ha_tokudb::test_row_packing(uchar* record, DBT* pk_key, DBT* pk_val) {
tmp_buff = (uchar *)my_malloc(alloced_rec_buff_length,MYF(MY_WME));
assert(tmp_buff);
row_desc = (uchar *)share->key_file[keynr]->descriptor->dbt.data;
row_desc += (*(u_int32_t *)row_desc);
row_desc += (*(u_int32_t *)row_desc);
desc_size = (*(u_int32_t *)row_desc) - 4;
row_desc += (*(uint32_t *)row_desc);
row_desc += (*(uint32_t *)row_desc);
desc_size = (*(uint32_t *)row_desc) - 4;
row_desc += 4;
tmp_num_bytes = pack_clustering_val_from_desc(
tmp_buff,
@@ -3667,10 +3667,10 @@ void ha_tokudb::test_row_packing(uchar* record, DBT* pk_key, DBT* pk_val) {
void ha_tokudb::set_main_dict_put_flags(
THD* thd,
bool opt_eligible,
u_int32_t* put_flags
uint32_t* put_flags
)
{
u_int32_t old_prelock_flags = 0;
uint32_t old_prelock_flags = 0;
uint curr_num_DBs = table->s->keys + test(hidden_primary_key);
bool in_hot_index = share->num_DBs > curr_num_DBs;
bool using_ignore_flag_opt = do_ignore_flag_optimization(
@@ -3713,7 +3713,7 @@ void ha_tokudb::set_main_dict_put_flags(
int ha_tokudb::insert_row_to_main_dictionary(uchar* record, DBT* pk_key, DBT* pk_val, DB_TXN* txn) {
int error = 0;
u_int32_t put_flags = mult_put_flags[primary_key];
uint32_t put_flags = mult_put_flags[primary_key];
THD *thd = ha_thd();
uint curr_num_DBs = table->s->keys + test(hidden_primary_key);
@@ -4234,8 +4234,8 @@ cleanup:
// and var_cols_for_query
//
void ha_tokudb::set_query_columns(uint keynr) {
u_int32_t curr_fixed_col_index = 0;
u_int32_t curr_var_col_index = 0;
uint32_t curr_fixed_col_index = 0;
uint32_t curr_var_col_index = 0;
read_key = false;
read_blobs = false;
//
@@ -4699,7 +4699,7 @@ int ha_tokudb::index_read(uchar * buf, const uchar * key, uint key_len, enum ha_
DBT row;
DBT lookup_key;
int error = 0;
u_int32_t flags = 0;
uint32_t flags = 0;
THD* thd = ha_thd();
tokudb_trx_data* trx = (tokudb_trx_data *) thd_data_get(thd, tokudb_hton->slot);;
struct smart_dbt_info info;
@@ -4801,7 +4801,7 @@ int ha_tokudb::read_data_from_range_query_buff(uchar* buf, bool need_val) {
memset((void *) &curr_key, 0, sizeof(curr_key));
// get key info
u_int32_t key_size = *(u_int32_t *)curr_pos;
uint32_t key_size = *(uint32_t *)curr_pos;
curr_pos += sizeof(key_size);
uchar* curr_key_buff = curr_pos;
curr_pos += key_size;
@@ -4821,7 +4821,7 @@ int ha_tokudb::read_data_from_range_query_buff(uchar* buf, bool need_val) {
DBT curr_val;
memset((void *) &curr_val, 0, sizeof(curr_val));
uchar* curr_val_buff = NULL;
u_int32_t val_size = 0;
uint32_t val_size = 0;
// in this case, we don't have a val, we are simply extracting the pk
if (!need_val) {
curr_val.data = curr_val_buff;
@@ -4834,7 +4834,7 @@ int ha_tokudb::read_data_from_range_query_buff(uchar* buf, bool need_val) {
// need to extract a val and place it into buf
if (unpack_entire_row) {
// get val info
val_size = *(u_int32_t *)curr_pos;
val_size = *(uint32_t *)curr_pos;
curr_pos += sizeof(val_size);
curr_val_buff = curr_pos;
curr_pos += val_size;
@@ -4853,7 +4853,7 @@ int ha_tokudb::read_data_from_range_query_buff(uchar* buf, bool need_val) {
curr_pos += table_share->null_bytes;
// now the fixed sized rows
for (u_int32_t i = 0; i < num_fixed_cols_for_query; i++) {
for (uint32_t i = 0; i < num_fixed_cols_for_query; i++) {
uint field_index = fixed_cols_for_query[i];
Field* field = table->field[field_index];
unpack_fixed_field(
@@ -4864,10 +4864,10 @@ int ha_tokudb::read_data_from_range_query_buff(uchar* buf, bool need_val) {
curr_pos += share->kc_info.field_lengths[field_index];
}
// now the variable sized rows
for (u_int32_t i = 0; i < num_var_cols_for_query; i++) {
for (uint32_t i = 0; i < num_var_cols_for_query; i++) {
uint field_index = var_cols_for_query[i];
Field* field = table->field[field_index];
u_int32_t field_len = *(u_int32_t *)curr_pos;
uint32_t field_len = *(uint32_t *)curr_pos;
curr_pos += sizeof(field_len);
unpack_var_field(
buf + field_offset(field, table),
@@ -4879,7 +4879,7 @@ int ha_tokudb::read_data_from_range_query_buff(uchar* buf, bool need_val) {
}
// now the blobs
if (read_blobs) {
u_int32_t blob_size = *(u_int32_t *)curr_pos;
uint32_t blob_size = *(uint32_t *)curr_pos;
curr_pos += sizeof(blob_size);
error = unpack_blobs(
buf,
@@ -4921,24 +4921,24 @@ int ha_tokudb::fill_range_query_buf(
//
// first put the value into range_query_buf
//
u_int32_t size_remaining = size_range_query_buff - bytes_used_in_range_query_buff;
u_int32_t size_needed;
u_int32_t user_defined_size = get_tokudb_read_buf_size(thd);
uint32_t size_remaining = size_range_query_buff - bytes_used_in_range_query_buff;
uint32_t size_needed;
uint32_t user_defined_size = get_tokudb_read_buf_size(thd);
uchar* curr_pos = NULL;
if (need_val) {
if (unpack_entire_row) {
size_needed = 2*sizeof(u_int32_t) + key->size + row->size;
size_needed = 2*sizeof(uint32_t) + key->size + row->size;
}
else {
// this is an upper bound
size_needed = sizeof(u_int32_t) + // size of key length
size_needed = sizeof(uint32_t) + // size of key length
key->size + row->size + //key and row
num_var_cols_for_query*(sizeof(u_int32_t)) + //lengths of varchars stored
sizeof(u_int32_t); //length of blobs
num_var_cols_for_query*(sizeof(uint32_t)) + //lengths of varchars stored
sizeof(uint32_t); //length of blobs
}
}
else {
size_needed = sizeof(u_int32_t) + key->size;
size_needed = sizeof(uint32_t) + key->size;
}
if (size_remaining < size_needed) {
range_query_buff = (uchar *)my_realloc(
@@ -4958,14 +4958,14 @@ int ha_tokudb::fill_range_query_buf(
//
curr_pos = range_query_buff + bytes_used_in_range_query_buff;
*(u_int32_t *)curr_pos = key->size;
curr_pos += sizeof(u_int32_t);
*(uint32_t *)curr_pos = key->size;
curr_pos += sizeof(uint32_t);
memcpy(curr_pos, key->data, key->size);
curr_pos += key->size;
if (need_val) {
if (unpack_entire_row) {
*(u_int32_t *)curr_pos = row->size;
curr_pos += sizeof(u_int32_t);
*(uint32_t *)curr_pos = row->size;
curr_pos += sizeof(uint32_t);
memcpy(curr_pos, row->data, row->size);
curr_pos += row->size;
}
@@ -4987,7 +4987,7 @@ int ha_tokudb::fill_range_query_buf(
//
// first the fixed fields
//
for (u_int32_t i = 0; i < num_fixed_cols_for_query; i++) {
for (uint32_t i = 0; i < num_fixed_cols_for_query; i++) {
uint field_index = fixed_cols_for_query[i];
memcpy(
curr_pos,
@@ -5000,11 +5000,11 @@ int ha_tokudb::fill_range_query_buf(
//
// now the var fields
//
for (u_int32_t i = 0; i < num_var_cols_for_query; i++) {
for (uint32_t i = 0; i < num_var_cols_for_query; i++) {
uint field_index = var_cols_for_query[i];
u_int32_t var_field_index = share->kc_info.cp_info[active_index][field_index].col_pack_val;
u_int32_t data_start_offset;
u_int32_t field_len;
uint32_t var_field_index = share->kc_info.cp_info[active_index][field_index].col_pack_val;
uint32_t data_start_offset;
uint32_t field_len;
get_var_field_info(
&field_len,
@@ -5020,8 +5020,8 @@ int ha_tokudb::fill_range_query_buf(
}
if (read_blobs) {
u_int32_t blob_offset = 0;
u_int32_t data_size = 0;
uint32_t blob_offset = 0;
uint32_t data_size = 0;
//
// now the blobs
//
@@ -5031,7 +5031,7 @@ int ha_tokudb::fill_range_query_buf(
var_field_data_ptr,
share->kc_info.num_offset_bytes
);
data_size = row->size - blob_offset - (u_int32_t)(var_field_data_ptr - (const uchar *)row->data);
data_size = row->size - blob_offset - (uint32_t)(var_field_data_ptr - (const uchar *)row->data);
memcpy(curr_pos, &data_size, sizeof(data_size));
curr_pos += sizeof(data_size);
memcpy(curr_pos, var_field_data_ptr + blob_offset, data_size);
@@ -5111,7 +5111,7 @@ cleanup:
int ha_tokudb::get_next(uchar* buf, int direction) {
int error = 0;
u_int32_t flags = SET_PRELOCK_FLAG(0);
uint32_t flags = SET_PRELOCK_FLAG(0);
THD* thd = ha_thd();
tokudb_trx_data* trx = (tokudb_trx_data *) thd_data_get(thd, tokudb_hton->slot);;
bool need_val;
@@ -5244,7 +5244,7 @@ int ha_tokudb::index_first(uchar * buf) {
invalidate_bulk_fetch();
int error = 0;
struct smart_dbt_info info;
u_int32_t flags = SET_PRELOCK_FLAG(0);
uint32_t flags = SET_PRELOCK_FLAG(0);
THD* thd = ha_thd();
tokudb_trx_data* trx = (tokudb_trx_data *) thd_data_get(thd, tokudb_hton->slot);;
HANDLE_INVALID_CURSOR();
@@ -5287,7 +5287,7 @@ int ha_tokudb::index_last(uchar * buf) {
invalidate_bulk_fetch();
int error = 0;
struct smart_dbt_info info;
u_int32_t flags = SET_PRELOCK_FLAG(0);
uint32_t flags = SET_PRELOCK_FLAG(0);
THD* thd = ha_thd();
tokudb_trx_data* trx = (tokudb_trx_data *) thd_data_get(thd, tokudb_hton->slot);;
HANDLE_INVALID_CURSOR();
@@ -5430,8 +5430,8 @@ DBT *ha_tokudb::get_pos(DBT * to, uchar * pos) {
TOKUDB_DBUG_ENTER("ha_tokudb::get_pos");
/* We don't need to set app_data here */
memset((void *) to, 0, sizeof(*to));
to->data = pos + sizeof(u_int32_t);
to->size = *(u_int32_t *)pos;
to->data = pos + sizeof(uint32_t);
to->size = *(uint32_t *)pos;
DBUG_DUMP("key", (const uchar *) to->data, to->size);
DBUG_RETURN(to);
}
@@ -5613,20 +5613,20 @@ void ha_tokudb::position(const uchar * record) {
TOKUDB_DBUG_ENTER("ha_tokudb::position");
DBT key;
if (hidden_primary_key) {
DBUG_ASSERT(ref_length == (TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH + sizeof(u_int32_t)));
memcpy_fixed(ref + sizeof(u_int32_t), current_ident, TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH);
*(u_int32_t *)ref = TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH;
DBUG_ASSERT(ref_length == (TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH + sizeof(uint32_t)));
memcpy_fixed(ref + sizeof(uint32_t), current_ident, TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH);
*(uint32_t *)ref = TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH;
}
else {
bool has_null;
//
// save the data
//
create_dbt_key_from_table(&key, primary_key, ref + sizeof(u_int32_t), record, &has_null);
create_dbt_key_from_table(&key, primary_key, ref + sizeof(uint32_t), record, &has_null);
//
// save the size of data in the first four bytes of ref
//
memcpy(ref, &key.size, sizeof(u_int32_t));
memcpy(ref, &key.size, sizeof(uint32_t));
}
DBUG_VOID_RETURN;
}
@@ -5652,7 +5652,7 @@ int ha_tokudb::info(uint flag) {
}
stats.deleted = 0;
if (!(flag & HA_STATUS_NO_LOCK)) {
u_int64_t num_rows = 0;
uint64_t num_rows = 0;
TOKU_DB_FRAGMENTATION_S frag_info;
memset(&frag_info, 0, sizeof frag_info);
@@ -5698,14 +5698,14 @@ int ha_tokudb::info(uint flag) {
// in this case, we have a hidden primary key, do not
// want to report space taken up by the hidden primary key to the user
//
u_int64_t hpk_space = TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH*dict_stats.bt_ndata;
uint64_t hpk_space = TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH*dict_stats.bt_ndata;
stats.data_file_length = (hpk_space > stats.data_file_length) ? 0 : stats.data_file_length - hpk_space;
}
else {
//
// one infinity byte per key needs to be subtracted
//
u_int64_t inf_byte_space = dict_stats.bt_ndata;
uint64_t inf_byte_space = dict_stats.bt_ndata;
stats.data_file_length = (inf_byte_space > stats.data_file_length) ? 0 : stats.data_file_length - inf_byte_space;
}
@@ -5875,7 +5875,7 @@ int ha_tokudb::create_txn(THD* thd, tokudb_trx_data* trx) {
TOKUDB_TRACE("just created master:%p\n", trx->all);
}
trx->sp_level = trx->all;
trans_register_ha(thd, TRUE, tokudb_hton);
trans_register_ha(thd, true, tokudb_hton);
}
DBUG_PRINT("trans", ("starting transaction stmt"));
if (trx->stmt) {
@@ -5883,7 +5883,7 @@ int ha_tokudb::create_txn(THD* thd, tokudb_trx_data* trx) {
TOKUDB_TRACE("warning:stmt=%p\n", trx->stmt);
}
}
u_int32_t txn_begin_flags;
uint32_t txn_begin_flags;
if (trx->all == NULL) {
txn_begin_flags = toku_iso_to_txn_flag(toku_iso_level);
if (txn_begin_flags == 0 && is_autocommit && thd_sql_command(thd) == SQLCOM_SELECT) {
@@ -5903,7 +5903,7 @@ int ha_tokudb::create_txn(THD* thd, tokudb_trx_data* trx) {
TOKUDB_TRACE("just created stmt:%p:%p\n", trx->sp_level, trx->stmt);
}
reset_stmt_progress(&trx->stmt_progress);
trans_register_ha(thd, FALSE, tokudb_hton);
trans_register_ha(thd, false, tokudb_hton);
cleanup:
return error;
}
@@ -6062,13 +6062,13 @@ int ha_tokudb::start_stmt(THD * thd, thr_lock_type lock_type) {
share->rows_from_locked_table = added_rows - deleted_rows;
}
transaction = trx->sub_sp_level;
trans_register_ha(thd, FALSE, tokudb_hton);
trans_register_ha(thd, false, tokudb_hton);
cleanup:
TOKUDB_DBUG_RETURN(error);
}
u_int32_t ha_tokudb::get_cursor_isolation_flags(enum thr_lock_type lock_type, THD* thd) {
uint32_t ha_tokudb::get_cursor_isolation_flags(enum thr_lock_type lock_type, THD* thd) {
uint sql_command = thd_sql_command(thd);
bool in_lock_tables = thd_in_lock_tables(thd);
@@ -6241,7 +6241,7 @@ static int create_sub_table(
TOKUDB_DBUG_ENTER("create_sub_table");
int error;
DB *file = NULL;
u_int32_t create_flags;
uint32_t create_flags;
error = db_create(&file, db_env, 0);
@@ -6392,22 +6392,22 @@ void ha_tokudb::trace_create_table_info(const char *name, TABLE * form) {
}
}
static u_int32_t get_max_desc_size(KEY_AND_COL_INFO* kc_info, TABLE* form) {
u_int32_t max_row_desc_buff_size;
static uint32_t get_max_desc_size(KEY_AND_COL_INFO* kc_info, TABLE* form) {
uint32_t max_row_desc_buff_size;
max_row_desc_buff_size = 2*(form->s->fields * 6)+10; // upper bound of key comparison descriptor
max_row_desc_buff_size += get_max_secondary_key_pack_desc_size(kc_info); // upper bound for sec. key part
max_row_desc_buff_size += get_max_clustering_val_pack_desc_size(form->s); // upper bound for clustering val part
return max_row_desc_buff_size;
}
static u_int32_t create_secondary_key_descriptor(
static uint32_t create_secondary_key_descriptor(
uchar* buf,
KEY* key_info,
KEY* prim_key,
uint hpk,
TABLE* form,
uint primary_key,
u_int32_t keynr,
uint32_t keynr,
KEY_AND_COL_INFO* kc_info
)
{
@@ -6453,7 +6453,7 @@ int ha_tokudb::create_secondary_dictionary(
KEY* key_info,
DB_TXN* txn,
KEY_AND_COL_INFO* kc_info,
u_int32_t keynr,
uint32_t keynr,
bool is_hot_index,
enum row_type row_type
)
@@ -6464,7 +6464,7 @@ int ha_tokudb::create_secondary_dictionary(
char* newname = NULL;
KEY* prim_key = NULL;
char dict_name[MAX_DICT_NAME_LEN];
u_int32_t max_row_desc_buff_size;
uint32_t max_row_desc_buff_size;
uint hpk= (form->s->primary_key >= MAX_KEY) ? TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH : 0;
uint32_t block_size;
uint32_t read_block_size;
@@ -6518,7 +6518,7 @@ cleanup:
}
static u_int32_t create_main_key_descriptor(
static uint32_t create_main_key_descriptor(
uchar* buf,
KEY* prim_key,
uint hpk,
@@ -6561,7 +6561,7 @@ int ha_tokudb::create_main_dictionary(const char* name, TABLE* form, DB_TXN* txn
uchar* row_desc_buff = NULL;
char* newname = NULL;
KEY* prim_key = NULL;
u_int32_t max_row_desc_buff_size;
uint32_t max_row_desc_buff_size;
uint hpk= (form->s->primary_key >= MAX_KEY) ? TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH : 0;
uint32_t block_size;
uint32_t read_block_size;
@@ -7115,9 +7115,9 @@ ha_rows ha_tokudb::records_in_range(uint keynr, key_range* start_key, key_range*
DBT key;
ha_rows ret_val = HA_TOKUDB_RANGE_COUNT;
DB *kfile = share->key_file[keynr];
u_int64_t less, equal, greater;
u_int64_t total_rows_estimate = HA_TOKUDB_RANGE_COUNT;
u_int64_t start_rows, end_rows, rows;
uint64_t less, equal, greater;
uint64_t total_rows_estimate = HA_TOKUDB_RANGE_COUNT;
uint64_t start_rows, end_rows, rows;
int is_exact;
int error;
uchar inf_byte;
@@ -7364,11 +7364,11 @@ int ha_tokudb::tokudb_add_index(
DB_INDEXER* indexer = NULL;
bool loader_use_puts = get_load_save_space(thd);
bool use_hot_index = (lock.type == TL_WRITE_ALLOW_WRITE);
u_int32_t loader_flags = loader_use_puts ? LOADER_USE_PUTS : 0;
u_int32_t indexer_flags = 0;
u_int32_t mult_db_flags[MAX_KEY + 1] = {0};
u_int32_t mult_put_flags[MAX_KEY + 1];
u_int32_t mult_dbt_flags[MAX_KEY + 1];
uint32_t loader_flags = loader_use_puts ? LOADER_USE_PUTS : 0;
uint32_t indexer_flags = 0;
uint32_t mult_db_flags[MAX_KEY + 1] = {0};
uint32_t mult_put_flags[MAX_KEY + 1];
uint32_t mult_dbt_flags[MAX_KEY + 1];
bool creating_hot_index = false;
struct loader_context lc;
memset(&lc, 0, sizeof lc);
@@ -7380,7 +7380,7 @@ int ha_tokudb::tokudb_add_index(
*modified_DBs = false;
invalidate_bulk_fetch();
unpack_entire_row = true; // for bulk fetching rows
for (u_int32_t i = 0; i < MAX_KEY+1; i++) {
for (uint32_t i = 0; i < MAX_KEY+1; i++) {
mult_put_flags[i] = 0;
mult_dbt_flags[i] = DB_DBT_REALLOC;
}
@@ -7526,7 +7526,7 @@ int ha_tokudb::tokudb_add_index(
// you need the val if you have a clustering index and key_read is not 0;
bf_info.direction = 1;
bf_info.thd = ha_thd();
bf_info.need_val = TRUE;
bf_info.need_val = true;
error = db_env->create_loader(
db_env,
@@ -7596,14 +7596,14 @@ int ha_tokudb::tokudb_add_index(
// at this point, we know the range query buffer has at least one key/val pair
uchar* curr_pos = range_query_buff+curr_range_query_buff_offset;
u_int32_t key_size = *(u_int32_t *)curr_pos;
uint32_t key_size = *(uint32_t *)curr_pos;
curr_pos += sizeof(key_size);
uchar* curr_key_buff = curr_pos;
curr_pos += key_size;
curr_pk_key.data = curr_key_buff;
curr_pk_key.size = key_size;
u_int32_t val_size = *(u_int32_t *)curr_pos;
uint32_t val_size = *(uint32_t *)curr_pos;
curr_pos += sizeof(val_size);
uchar* curr_val_buff = curr_pos;
curr_pos += val_size;

58
storage/tokudb/ha_tokudb.h
View File

@@ -81,7 +81,7 @@ typedef struct st_tokudb_share {
bool has_unique_keys;
bool replace_into_fast;
rw_lock_t num_DBs_lock;
u_int32_t num_DBs;
uint32_t num_DBs;
} TOKUDB_SHARE;
#define HA_TOKU_ORIG_VERSION 4
@@ -149,12 +149,12 @@ private:
//
uchar *rec_update_buff;
ulong alloced_update_rec_buff_length;
u_int32_t max_key_length;
uint32_t max_key_length;
uchar* range_query_buff; // range query buffer
u_int32_t size_range_query_buff; // size of the allocated range query buffer
u_int32_t bytes_used_in_range_query_buff; // number of bytes used in the range query buffer
u_int32_t curr_range_query_buff_offset; // current offset into the range query buffer for queries to read
uint32_t size_range_query_buff; // size of the allocated range query buffer
uint32_t bytes_used_in_range_query_buff; // number of bytes used in the range query buffer
uint32_t curr_range_query_buff_offset; // current offset into the range query buffer for queries to read
uint64_t bulk_fetch_iteration;
uint64_t rows_fetched_using_bulk_fetch;
bool doing_bulk_fetch;
@@ -185,9 +185,9 @@ private:
// ranges of prelocked area, used to know how much to bulk fetch
//
uchar *prelocked_left_range;
u_int32_t prelocked_left_range_size;
uint32_t prelocked_left_range_size;
uchar *prelocked_right_range;
u_int32_t prelocked_right_range_size;
uint32_t prelocked_right_range_size;
//
@@ -195,9 +195,9 @@ private:
//
DBT mult_key_dbt[2*(MAX_KEY + 1)];
DBT mult_rec_dbt[MAX_KEY + 1];
u_int32_t mult_put_flags[MAX_KEY + 1];
u_int32_t mult_del_flags[MAX_KEY + 1];
u_int32_t mult_dbt_flags[MAX_KEY + 1];
uint32_t mult_put_flags[MAX_KEY + 1];
uint32_t mult_del_flags[MAX_KEY + 1];
uint32_t mult_dbt_flags[MAX_KEY + 1];
//
@@ -207,7 +207,7 @@ private:
// query
//
uchar* blob_buff;
u_int32_t num_blob_bytes;
uint32_t num_blob_bytes;
bool unpack_entire_row;
@@ -215,10 +215,10 @@ private:
// buffers (and their sizes) that will hold the indexes
// of fields that need to be read for a query
//
u_int32_t* fixed_cols_for_query;
u_int32_t num_fixed_cols_for_query;
u_int32_t* var_cols_for_query;
u_int32_t num_var_cols_for_query;
uint32_t* fixed_cols_for_query;
uint32_t num_fixed_cols_for_query;
uint32_t* var_cols_for_query;
uint32_t num_var_cols_for_query;
bool read_blobs;
bool read_key;
@@ -235,7 +235,7 @@ private:
// instance of cursor being used for init_xxx and rnd_xxx functions
//
DBC *cursor;
u_int32_t cursor_flags; // flags for cursor
uint32_t cursor_flags; // flags for cursor
//
// flags that are returned in table_flags()
//
@@ -265,7 +265,7 @@ private:
//
// For instances where we successfully prelock a range or a table,
// we set this to TRUE so that successive cursor calls can know
// we set this to true so that successive cursor calls can know
// know to limit the locking overhead in a call to the fractal tree
//
bool range_lock_grabbed;
@@ -291,7 +291,7 @@ private:
int loader_error;
bool num_DBs_locked_in_bulk;
u_int32_t lock_count;
uint32_t lock_count;
bool fix_rec_buff_for_blob(ulong length);
bool fix_rec_update_buff_for_blob(ulong length);
@@ -314,9 +314,9 @@ private:
const uchar* record,
uint index
);
u_int32_t place_key_into_mysql_buff(KEY* key_info, uchar * record, uchar* data);
uint32_t place_key_into_mysql_buff(KEY* key_info, uchar * record, uchar* data);
void unpack_key(uchar * record, DBT const *key, uint index);
u_int32_t place_key_into_dbt_buff(KEY* key_info, uchar * buff, const uchar * record, bool* has_null, int key_length);
uint32_t place_key_into_dbt_buff(KEY* key_info, uchar * buff, const uchar * record, bool* has_null, int key_length);
DBT* create_dbt_key_from_key(DBT * key, KEY* key_info, uchar * buff, const uchar * record, bool* has_null, bool dont_pack_pk, int key_length = MAX_KEY_LENGTH);
DBT *create_dbt_key_from_table(DBT * key, uint keynr, uchar * buff, const uchar * record, bool* has_null, int key_length = MAX_KEY_LENGTH);
DBT* create_dbt_key_for_lookup(DBT * key, KEY* key_info, uchar * buff, const uchar * record, bool* has_null, int key_length = MAX_KEY_LENGTH);
@@ -328,7 +328,7 @@ private:
int open_main_dictionary(const char* name, bool is_read_only, DB_TXN* txn);
int open_secondary_dictionary(DB** ptr, KEY* key_info, const char* name, bool is_read_only, DB_TXN* txn);
int acquire_table_lock (DB_TXN* trans, TABLE_LOCK_TYPE lt);
int estimate_num_rows(DB* db, u_int64_t* num_rows, DB_TXN* txn);
int estimate_num_rows(DB* db, uint64_t* num_rows, DB_TXN* txn);
bool has_auto_increment_flag(uint* index);
int write_frm_data(DB* db, DB_TXN* txn, const char* frm_name);
@@ -365,7 +365,7 @@ private:
KEY* key_info,
DB_TXN* txn,
KEY_AND_COL_INFO* kc_info,
u_int32_t keynr,
uint32_t keynr,
bool is_hot_index,
enum row_type row_type
);
@@ -374,17 +374,17 @@ private:
int is_index_unique(bool* is_unique, DB_TXN* txn, DB* db, KEY* key_info);
int is_val_unique(bool* is_unique, uchar* record, KEY* key_info, uint dict_index, DB_TXN* txn);
int do_uniqueness_checks(uchar* record, DB_TXN* txn, THD* thd);
void set_main_dict_put_flags(THD* thd, bool opt_eligible, u_int32_t* put_flags);
void set_main_dict_put_flags(THD* thd, bool opt_eligible, uint32_t* put_flags);
int insert_row_to_main_dictionary(uchar* record, DBT* pk_key, DBT* pk_val, DB_TXN* txn);
int insert_rows_to_dictionaries_mult(DBT* pk_key, DBT* pk_val, DB_TXN* txn, THD* thd);
void test_row_packing(uchar* record, DBT* pk_key, DBT* pk_val);
u_int32_t fill_row_mutator(
uint32_t fill_row_mutator(
uchar* buf,
u_int32_t* dropped_columns,
u_int32_t num_dropped_columns,
uint32_t* dropped_columns,
uint32_t num_dropped_columns,
TABLE* altered_table,
KEY_AND_COL_INFO* altered_kc_info,
u_int32_t keynr,
uint32_t keynr,
bool is_add
);
@@ -490,7 +490,7 @@ public:
ha_rows records_in_range(uint inx, key_range * min_key, key_range * max_key);
u_int32_t get_cursor_isolation_flags(enum thr_lock_type lock_type, THD* thd);
uint32_t get_cursor_isolation_flags(enum thr_lock_type lock_type, THD* thd);
THR_LOCK_DATA **store_lock(THD * thd, THR_LOCK_DATA ** to, enum thr_lock_type lock_type);
int get_status(DB_TXN* trans);
@@ -609,7 +609,7 @@ public:
int unpack_blobs(
uchar* record,
const uchar* from_tokudb_blob,
u_int32_t num_blob_bytes,
uint32_t num_blob_bytes,
bool check_bitmap
);
int unpack_row(

34
storage/tokudb/ha_tokudb_alter_51.cc
View File

@@ -306,8 +306,8 @@ ha_tokudb::check_if_supported_alter(TABLE *altered_table,
goto cleanup;
}
if (has_added_columns && !has_non_added_changes) {
u_int32_t added_columns[altered_table->s->fields];
u_int32_t num_added_columns = 0;
uint32_t added_columns[altered_table->s->fields];
uint32_t num_added_columns = 0;
int r = find_changed_columns(
added_columns,
&num_added_columns,
@@ -319,8 +319,8 @@ ha_tokudb::check_if_supported_alter(TABLE *altered_table,
goto cleanup;
}
if (tokudb_debug & TOKUDB_DEBUG_ALTER_TABLE_INFO) {
for (u_int32_t i = 0; i < num_added_columns; i++) {
u_int32_t curr_added_index = added_columns[i];
for (uint32_t i = 0; i < num_added_columns; i++) {
uint32_t curr_added_index = added_columns[i];
Field* curr_added_field = altered_table->field[curr_added_index];
printf(
"Added column: index %d, name %s\n",
@@ -331,8 +331,8 @@ ha_tokudb::check_if_supported_alter(TABLE *altered_table,
}
}
if (has_dropped_columns && !has_non_dropped_changes) {
u_int32_t dropped_columns[table->s->fields];
u_int32_t num_dropped_columns = 0;
uint32_t dropped_columns[table->s->fields];
uint32_t num_dropped_columns = 0;
int r = find_changed_columns(
dropped_columns,
&num_dropped_columns,
@@ -344,8 +344,8 @@ ha_tokudb::check_if_supported_alter(TABLE *altered_table,
goto cleanup;
}
if (tokudb_debug & TOKUDB_DEBUG_ALTER_TABLE_INFO) {
for (u_int32_t i = 0; i < num_dropped_columns; i++) {
u_int32_t curr_dropped_index = dropped_columns[i];
for (uint32_t i = 0; i < num_dropped_columns; i++) {
uint32_t curr_dropped_index = dropped_columns[i];
Field* curr_dropped_field = table->field[curr_dropped_index];
printf(
"Dropped column: index %d, name %s\n",
@@ -420,7 +420,7 @@ ha_tokudb::alter_table_phase2(
bool has_row_format_changes = alter_flags->is_set(HA_ALTER_ROW_FORMAT);
KEY_AND_COL_INFO altered_kc_info;
memset(&altered_kc_info, 0, sizeof(altered_kc_info));
u_int32_t max_new_desc_size = 0;
uint32_t max_new_desc_size = 0;
uchar* row_desc_buff = NULL;
uchar* column_extra = NULL;
bool dropping_indexes = alter_info->index_drop_count > 0 && !tables_have_same_keys(table,altered_table,false, false);
@@ -504,11 +504,11 @@ ha_tokudb::alter_table_phase2(
if (has_dropped_columns || has_added_columns) {
DBT column_dbt;
memset(&column_dbt, 0, sizeof(DBT));
u_int32_t max_column_extra_size;
u_int32_t num_column_extra;
u_int32_t columns[table->s->fields + altered_table->s->fields]; // set size such that we know it is big enough for both cases
u_int32_t num_columns = 0;
u_int32_t curr_num_DBs = table->s->keys + test(hidden_primary_key);
uint32_t max_column_extra_size;
uint32_t num_column_extra;
uint32_t columns[table->s->fields + altered_table->s->fields]; // set size such that we know it is big enough for both cases
uint32_t num_columns = 0;
uint32_t curr_num_DBs = table->s->keys + test(hidden_primary_key);
memset(columns, 0, sizeof(columns));
if (has_added_columns && has_dropped_columns) {
@@ -554,7 +554,7 @@ ha_tokudb::alter_table_phase2(
column_extra = (uchar *)my_malloc(max_column_extra_size, MYF(MY_WME));
if (column_extra == NULL) { error = ENOMEM; goto cleanup; }
for (u_int32_t i = 0; i < curr_num_DBs; i++) {
for (uint32_t i = 0; i < curr_num_DBs; i++) {
DBT row_descriptor;
memset(&row_descriptor, 0, sizeof(row_descriptor));
KEY* prim_key = (hidden_primary_key) ? NULL : &altered_table->s->key_info[primary_key];
@@ -624,8 +624,8 @@ ha_tokudb::alter_table_phase2(
method = row_type_to_compression_method(create_info->row_type);
// Set the new type.
u_int32_t curr_num_DBs = table->s->keys + test(hidden_primary_key);
for (u_int32_t i = 0; i < curr_num_DBs; ++i) {
uint32_t curr_num_DBs = table->s->keys + test(hidden_primary_key);
for (uint32_t i = 0; i < curr_num_DBs; ++i) {
DB *db = share->key_file[i];
error = db->change_compression_method(db, method);
if (error) {

38
storage/tokudb/ha_tokudb_alter_56.cc
View File

@@ -158,13 +158,13 @@ ha_tokudb::check_if_supported_inplace_alter(TABLE *altered_table, Alter_inplace_
} else
// add column
if (only_flags(handler_flags, Alter_inplace_info::ADD_COLUMN + Alter_inplace_info::ALTER_COLUMN_ORDER)) {
u_int32_t added_columns[altered_table->s->fields];
u_int32_t num_added_columns = 0;
uint32_t added_columns[altered_table->s->fields];
uint32_t num_added_columns = 0;
int r = find_changed_columns(added_columns, &num_added_columns, table, altered_table);
if (r == 0) {
if (tokudb_debug & TOKUDB_DEBUG_ALTER_TABLE_INFO) {
for (u_int32_t i = 0; i < num_added_columns; i++) {
u_int32_t curr_added_index = added_columns[i];
for (uint32_t i = 0; i < num_added_columns; i++) {
uint32_t curr_added_index = added_columns[i];
Field* curr_added_field = altered_table->field[curr_added_index];
printf("Added column: index %d, name %s\n", curr_added_index, curr_added_field->field_name);
}
@@ -174,13 +174,13 @@ ha_tokudb::check_if_supported_inplace_alter(TABLE *altered_table, Alter_inplace_
} else
// drop column
if (only_flags(handler_flags, Alter_inplace_info::DROP_COLUMN + Alter_inplace_info::ALTER_COLUMN_ORDER)) {
u_int32_t dropped_columns[table->s->fields];
u_int32_t num_dropped_columns = 0;
uint32_t dropped_columns[table->s->fields];
uint32_t num_dropped_columns = 0;
int r = find_changed_columns(dropped_columns, &num_dropped_columns, altered_table, table);
if (r == 0) {
if (tokudb_debug & TOKUDB_DEBUG_ALTER_TABLE_INFO) {
for (u_int32_t i = 0; i < num_dropped_columns; i++) {
u_int32_t curr_dropped_index = dropped_columns[i];
for (uint32_t i = 0; i < num_dropped_columns; i++) {
uint32_t curr_dropped_index = dropped_columns[i];
Field* curr_dropped_field = table->field[curr_dropped_index];
printf("Dropped column: index %d, name %s\n", curr_dropped_index, curr_dropped_field->field_name);
}
@@ -248,8 +248,8 @@ ha_tokudb::inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alte
assert(error == 0);
ctx->compression_changed = true;
// Set the new type.
u_int32_t curr_num_DBs = table->s->keys + test(hidden_primary_key);
for (u_int32_t i = 0; i < curr_num_DBs; i++) {
uint32_t curr_num_DBs = table->s->keys + test(hidden_primary_key);
for (uint32_t i = 0; i < curr_num_DBs; i++) {
db = share->key_file[i];
error = db->change_compression_method(db, method);
if (error)
@@ -315,13 +315,13 @@ ha_tokudb::alter_table_add_or_drop_column(TABLE *altered_table, Alter_inplace_in
int error;
uchar *column_extra = NULL;
uchar *row_desc_buff = NULL;
u_int32_t max_new_desc_size = 0;
u_int32_t max_column_extra_size;
u_int32_t num_column_extra;
u_int32_t num_columns = 0;
u_int32_t curr_num_DBs = table->s->keys + test(hidden_primary_key);
uint32_t max_new_desc_size = 0;
uint32_t max_column_extra_size;
uint32_t num_column_extra;
uint32_t num_columns = 0;
uint32_t curr_num_DBs = table->s->keys + test(hidden_primary_key);
u_int32_t columns[table->s->fields + altered_table->s->fields]; // set size such that we know it is big enough for both cases
uint32_t columns[table->s->fields + altered_table->s->fields]; // set size such that we know it is big enough for both cases
memset(columns, 0, sizeof(columns));
KEY_AND_COL_INFO altered_kc_info;
@@ -369,7 +369,7 @@ ha_tokudb::alter_table_add_or_drop_column(TABLE *altered_table, Alter_inplace_in
column_extra = (uchar *)my_malloc(max_column_extra_size, MYF(MY_WME));
if (column_extra == NULL) { error = ENOMEM; goto cleanup; }
for (u_int32_t i = 0; i < curr_num_DBs; i++) {
for (uint32_t i = 0; i < curr_num_DBs; i++) {
DBT row_descriptor;
memset(&row_descriptor, 0, sizeof(row_descriptor));
KEY* prim_key = (hidden_primary_key) ? NULL : &altered_table->s->key_info[primary_key];
@@ -495,8 +495,8 @@ ha_tokudb::commit_inplace_alter_table(TABLE *altered_table, Alter_inplace_info *
restore_drop_indexes(table, index_drop_offsets, ha_alter_info->index_drop_count);
}
if (ctx->compression_changed) {
u_int32_t curr_num_DBs = table->s->keys + test(hidden_primary_key);
for (u_int32_t i = 0; i < curr_num_DBs; i++) {
uint32_t curr_num_DBs = table->s->keys + test(hidden_primary_key);
for (uint32_t i = 0; i < curr_num_DBs; i++) {
DB *db = share->key_file[i];
int error = db->change_compression_method(db, ctx->orig_compression_method);
assert(error == 0);

104
storage/tokudb/ha_tokudb_alter_common.cc
View File

@@ -19,7 +19,7 @@ tables_have_same_keys(TABLE* table, TABLE* altered_table, bool print_error, bool
retval = false;
goto cleanup;
}
for (u_int32_t i=0; i < table->s->keys; i++) {
for (uint32_t i=0; i < table->s->keys; i++) {
KEY* curr_orig_key = &table->key_info[i];
KEY* curr_altered_key = &altered_table->key_info[i];
if (strcmp(curr_orig_key->name, curr_altered_key->name)) {
@@ -70,7 +70,7 @@ tables_have_same_keys(TABLE* table, TABLE* altered_table, bool print_error, bool
//
// now verify that each field in the key is the same
//
for (u_int32_t j = 0; j < curr_orig_key->key_parts; j++) {
for (uint32_t j = 0; j < curr_orig_key->key_parts; j++) {
KEY_PART_INFO* curr_orig_part = &curr_orig_key->key_part[j];
KEY_PART_INFO* curr_altered_part = &curr_altered_key->key_part[j];
Field* curr_orig_field = curr_orig_part->field;
@@ -115,9 +115,9 @@ cleanup:
// to evaluate whether a field is NULL or not. This value is a power of 2, from
// 2^0 to 2^7. We return the position of the bit within the byte, which is
// lg null_bit
static inline u_int32_t
get_null_bit_position(u_int32_t null_bit) {
u_int32_t retval = 0;
static inline uint32_t
get_null_bit_position(uint32_t null_bit) {
uint32_t retval = 0;
switch(null_bit) {
case (1):
retval = 0;
@@ -150,24 +150,24 @@ get_null_bit_position(u_int32_t null_bit) {
}
// returns the index of the null bit of field.
static inline u_int32_t
static inline uint32_t
get_overall_null_bit_position(TABLE* table, Field* field) {
u_int32_t offset = get_null_offset(table, field);
u_int32_t null_bit = field->null_bit;
uint32_t offset = get_null_offset(table, field);
uint32_t null_bit = field->null_bit;
return offset*8 + get_null_bit_position(null_bit);
}
// not static since 51 uses this and 56 does not
bool
are_null_bits_in_order(TABLE* table) {
u_int32_t curr_null_pos = 0;
uint32_t curr_null_pos = 0;
bool first = true;
bool retval = true;
for (uint i = 0; i < table->s->fields; i++) {
Field* curr_field = table->field[i];
bool nullable = (curr_field->null_bit != 0);
if (nullable) {
u_int32_t pos = get_overall_null_bit_position(
uint32_t pos = get_overall_null_bit_position(
table,
curr_field
);
@@ -182,9 +182,9 @@ are_null_bits_in_order(TABLE* table) {
return retval;
}
static u_int32_t
static uint32_t
get_first_null_bit_pos(TABLE* table) {
u_int32_t table_pos = 0;
uint32_t table_pos = 0;
for (uint i = 0; i < table->s->fields; i++) {
Field* curr_field = table->field[i];
bool nullable = (curr_field->null_bit != 0);
@@ -201,12 +201,12 @@ get_first_null_bit_pos(TABLE* table) {
#if 0
static bool
is_column_default_null(TABLE* src_table, u_int32_t field_index) {
is_column_default_null(TABLE* src_table, uint32_t field_index) {
Field* curr_field = src_table->field[field_index];
bool is_null_default = false;
bool nullable = curr_field->null_bit != 0;
if (nullable) {
u_int32_t null_bit_position = get_overall_null_bit_position(src_table, curr_field);
uint32_t null_bit_position = get_overall_null_bit_position(src_table, curr_field);
is_null_default = is_overall_null_position_set(
src_table->s->default_values,
null_bit_position
@@ -216,14 +216,14 @@ is_column_default_null(TABLE* src_table, u_int32_t field_index) {
}
#endif
static u_int32_t
static uint32_t
fill_static_row_mutator(
uchar* buf,
TABLE* orig_table,
TABLE* altered_table,
KEY_AND_COL_INFO* orig_kc_info,
KEY_AND_COL_INFO* altered_kc_info,
u_int32_t keynr
uint32_t keynr
)
{
//
@@ -255,7 +255,7 @@ fill_static_row_mutator(
//
// size of fixed fields
//
u_int32_t fixed_field_size = orig_kc_info->mcp_info[keynr].fixed_field_size;
uint32_t fixed_field_size = orig_kc_info->mcp_info[keynr].fixed_field_size;
memcpy(pos, &fixed_field_size, sizeof(fixed_field_size));
pos += sizeof(fixed_field_size);
fixed_field_size = altered_kc_info->mcp_info[keynr].fixed_field_size;
@@ -265,17 +265,17 @@ fill_static_row_mutator(
//
// length of offsets
//
u_int32_t len_of_offsets = orig_kc_info->mcp_info[keynr].len_of_offsets;
uint32_t len_of_offsets = orig_kc_info->mcp_info[keynr].len_of_offsets;
memcpy(pos, &len_of_offsets, sizeof(len_of_offsets));
pos += sizeof(len_of_offsets);
len_of_offsets = altered_kc_info->mcp_info[keynr].len_of_offsets;
memcpy(pos, &len_of_offsets, sizeof(len_of_offsets));
pos += sizeof(len_of_offsets);
u_int32_t orig_start_null_pos = get_first_null_bit_pos(orig_table);
uint32_t orig_start_null_pos = get_first_null_bit_pos(orig_table);
memcpy(pos, &orig_start_null_pos, sizeof(orig_start_null_pos));
pos += sizeof(orig_start_null_pos);
u_int32_t altered_start_null_pos = get_first_null_bit_pos(altered_table);
uint32_t altered_start_null_pos = get_first_null_bit_pos(altered_table);
memcpy(pos, &altered_start_null_pos, sizeof(altered_start_null_pos));
pos += sizeof(altered_start_null_pos);
@@ -283,25 +283,25 @@ fill_static_row_mutator(
return pos - buf;
}
static u_int32_t
static uint32_t
fill_dynamic_row_mutator(
uchar* buf,
u_int32_t* columns,
u_int32_t num_columns,
uint32_t* columns,
uint32_t num_columns,
TABLE* src_table,
KEY_AND_COL_INFO* src_kc_info,
u_int32_t keynr,
uint32_t keynr,
bool is_add,
bool* out_has_blobs
)
{
uchar* pos = buf;
bool has_blobs = false;
u_int32_t cols = num_columns;
uint32_t cols = num_columns;
memcpy(pos, &cols, sizeof(cols));
pos += sizeof(cols);
for (u_int32_t i = 0; i < num_columns; i++) {
u_int32_t curr_index = columns[i];
for (uint32_t i = 0; i < num_columns; i++) {
uint32_t curr_index = columns[i];
Field* curr_field = src_table->field[curr_index];
pos[0] = is_add ? COL_ADD : COL_DROP;
@@ -319,7 +319,7 @@ fill_dynamic_row_mutator(
pos[0] = 1;
pos++;
// write position of null byte that is to be removed
u_int32_t null_bit_position = get_overall_null_bit_position(src_table, curr_field);
uint32_t null_bit_position = get_overall_null_bit_position(src_table, curr_field);
memcpy(pos, &null_bit_position, sizeof(null_bit_position));
pos += sizeof(null_bit_position);
//
@@ -340,11 +340,11 @@ fill_dynamic_row_mutator(
pos[0] = COL_FIXED;
pos++;
//store the offset
u_int32_t fixed_field_offset = src_kc_info->cp_info[keynr][curr_index].col_pack_val;
uint32_t fixed_field_offset = src_kc_info->cp_info[keynr][curr_index].col_pack_val;
memcpy(pos, &fixed_field_offset, sizeof(fixed_field_offset));
pos += sizeof(fixed_field_offset);
//store the number of bytes
u_int32_t num_bytes = src_kc_info->field_lengths[curr_index];
uint32_t num_bytes = src_kc_info->field_lengths[curr_index];
memcpy(pos, &num_bytes, sizeof(num_bytes));
pos += sizeof(num_bytes);
if (is_add && !is_null_default) {
@@ -361,13 +361,13 @@ fill_dynamic_row_mutator(
pos[0] = COL_VAR;
pos++;
//store the index of the variable column
u_int32_t var_field_index = src_kc_info->cp_info[keynr][curr_index].col_pack_val;
uint32_t var_field_index = src_kc_info->cp_info[keynr][curr_index].col_pack_val;
memcpy(pos, &var_field_index, sizeof(var_field_index));
pos += sizeof(var_field_index);
if (is_add && !is_null_default) {
uint curr_field_offset = field_offset(curr_field, src_table);
u_int32_t len_bytes = src_kc_info->length_bytes[curr_index];
u_int32_t data_length = get_var_data_length(
uint32_t len_bytes = src_kc_info->length_bytes[curr_index];
uint32_t data_length = get_var_data_length(
src_table->s->default_values + curr_field_offset,
len_bytes
);
@@ -391,7 +391,7 @@ fill_dynamic_row_mutator(
return pos-buf;
}
static u_int32_t
static uint32_t
fill_static_blob_row_mutator(
uchar* buf,
TABLE* src_table,
@@ -403,10 +403,10 @@ fill_static_blob_row_mutator(
memcpy(pos, &src_kc_info->num_blobs, sizeof(src_kc_info->num_blobs));
pos += sizeof(src_kc_info->num_blobs);
// copy length bytes for each blob
for (u_int32_t i = 0; i < src_kc_info->num_blobs; i++) {
u_int32_t curr_field_index = src_kc_info->blob_fields[i];
for (uint32_t i = 0; i < src_kc_info->num_blobs; i++) {
uint32_t curr_field_index = src_kc_info->blob_fields[i];
Field* field = src_table->field[curr_field_index];
u_int32_t len_bytes = field->row_pack_length();
uint32_t len_bytes = field->row_pack_length();
assert(len_bytes <= 4);
pos[0] = len_bytes;
pos++;
@@ -415,27 +415,27 @@ fill_static_blob_row_mutator(
return pos-buf;
}
static u_int32_t
static uint32_t
fill_dynamic_blob_row_mutator(
uchar* buf,
u_int32_t* columns,
u_int32_t num_columns,
uint32_t* columns,
uint32_t num_columns,
TABLE* src_table,
KEY_AND_COL_INFO* src_kc_info,
bool is_add
)
{
uchar* pos = buf;
for (u_int32_t i = 0; i < num_columns; i++) {
u_int32_t curr_field_index = columns[i];
for (uint32_t i = 0; i < num_columns; i++) {
uint32_t curr_field_index = columns[i];
Field* curr_field = src_table->field[curr_field_index];
if (src_kc_info->field_lengths[curr_field_index] == 0 &&
src_kc_info->length_bytes[curr_field_index]== 0
)
{
// find out which blob it is
u_int32_t blob_index = src_kc_info->num_blobs;
for (u_int32_t j = 0; j < src_kc_info->num_blobs; j++) {
uint32_t blob_index = src_kc_info->num_blobs;
for (uint32_t j = 0; j < src_kc_info->num_blobs; j++) {
if (curr_field_index == src_kc_info->blob_fields[j]) {
blob_index = j;
break;
@@ -448,7 +448,7 @@ fill_dynamic_blob_row_mutator(
memcpy(pos, &blob_index, sizeof(blob_index));
pos += sizeof(blob_index);
if (is_add) {
u_int32_t len_bytes = curr_field->row_pack_length();
uint32_t len_bytes = curr_field->row_pack_length();
assert(len_bytes <= 4);
pos[0] = len_bytes;
pos++;
@@ -471,14 +471,14 @@ fill_dynamic_blob_row_mutator(
// TODO: carefully review to make sure that the right information is used
// TODO: namely, when do we get stuff from share->kc_info and when we get
// TODO: it from altered_kc_info, and when is keynr associated with the right thing
u_int32_t
uint32_t
ha_tokudb::fill_row_mutator(
uchar* buf,
u_int32_t* columns,
u_int32_t num_columns,
uint32_t* columns,
uint32_t num_columns,
TABLE* altered_table,
KEY_AND_COL_INFO* altered_kc_info,
u_int32_t keynr,
uint32_t keynr,
bool is_add
)
{
@@ -626,15 +626,15 @@ cleanup:
static int
find_changed_columns(
u_int32_t* changed_columns,
u_int32_t* num_changed_columns,
uint32_t* changed_columns,
uint32_t* num_changed_columns,
TABLE* smaller_table,
TABLE* bigger_table
)
{
int retval;
uint curr_new_col_index = 0;
u_int32_t curr_num_changed_columns=0;
uint32_t curr_num_changed_columns=0;
assert(bigger_table->s->fields > smaller_table->s->fields);
for (uint i = 0; i < smaller_table->s->fields; i++, curr_new_col_index++) {
if (curr_new_col_index >= bigger_table->s->fields) {

182
storage/tokudb/ha_tokudb_update_fun.cc
View File

@@ -54,8 +54,8 @@ So, upperbound is num_blobs(1+4+1+4) = num_columns*10
// checks whether the bit at index pos in data is set or not
//
static inline bool
is_overall_null_position_set(uchar* data, u_int32_t pos) {
u_int32_t offset = pos/8;
is_overall_null_position_set(uchar* data, uint32_t pos) {
uint32_t offset = pos/8;
uchar remainder = pos%8;
uchar null_bit = 1<<remainder;
return ((data[offset] & null_bit) != 0);
@@ -65,8 +65,8 @@ is_overall_null_position_set(uchar* data, u_int32_t pos) {
// sets the bit at index pos in data to 1 if is_null, 0 otherwise
//
static inline void
set_overall_null_position(uchar* data, u_int32_t pos, bool is_null) {
u_int32_t offset = pos/8;
set_overall_null_position(uchar* data, uint32_t pos, bool is_null) {
uint32_t offset = pos/8;
uchar remainder = pos%8;
uchar null_bit = 1<<remainder;
if (is_null) {
@@ -79,16 +79,16 @@ set_overall_null_position(uchar* data, u_int32_t pos, bool is_null) {
static inline void
copy_null_bits(
u_int32_t start_old_pos,
u_int32_t start_new_pos,
u_int32_t num_bits,
uint32_t start_old_pos,
uint32_t start_new_pos,
uint32_t num_bits,
uchar* old_null_bytes,
uchar* new_null_bytes
)
{
for (u_int32_t i = 0; i < num_bits; i++) {
u_int32_t curr_old_pos = i + start_old_pos;
u_int32_t curr_new_pos = i + start_new_pos;
for (uint32_t i = 0; i < num_bits; i++) {
uint32_t curr_old_pos = i + start_old_pos;
uint32_t curr_new_pos = i + start_new_pos;
// copy over old null bytes
if (is_overall_null_position_set(old_null_bytes,curr_old_pos)) {
set_overall_null_position(new_null_bytes,curr_new_pos,true);
@@ -101,25 +101,25 @@ copy_null_bits(
static inline void
copy_var_fields(
u_int32_t start_old_num_var_field, //index of var fields that we should start writing
u_int32_t num_var_fields, // number of var fields to copy
uint32_t start_old_num_var_field, //index of var fields that we should start writing
uint32_t num_var_fields, // number of var fields to copy
uchar* old_var_field_offset_ptr, //static ptr to where offset bytes begin in old row
uchar old_num_offset_bytes, //number of offset bytes used in old row
uchar* start_new_var_field_data_ptr, // where the new var data should be written
uchar* start_new_var_field_offset_ptr, // where the new var offsets should be written
uchar* new_var_field_data_ptr, // pointer to beginning of var fields in new row
uchar* old_var_field_data_ptr, // pointer to beginning of var fields in old row
u_int32_t new_num_offset_bytes, // number of offset bytes used in new row
u_int32_t* num_data_bytes_written,
u_int32_t* num_offset_bytes_written
uint32_t new_num_offset_bytes, // number of offset bytes used in new row
uint32_t* num_data_bytes_written,
uint32_t* num_offset_bytes_written
)
{
uchar* curr_new_var_field_data_ptr = start_new_var_field_data_ptr;
uchar* curr_new_var_field_offset_ptr = start_new_var_field_offset_ptr;
for (u_int32_t i = 0; i < num_var_fields; i++) {
u_int32_t field_len;
u_int32_t start_read_offset;
u_int32_t curr_old = i + start_old_num_var_field;
for (uint32_t i = 0; i < num_var_fields; i++) {
uint32_t field_len;
uint32_t start_read_offset;
uint32_t curr_old = i + start_old_num_var_field;
uchar* data_to_copy = NULL;
// get the length and pointer to data that needs to be copied
get_var_field_info(
@@ -141,13 +141,13 @@ copy_var_fields(
);
curr_new_var_field_offset_ptr += new_num_offset_bytes;
}
*num_data_bytes_written = (u_int32_t)(curr_new_var_field_data_ptr - start_new_var_field_data_ptr);
*num_offset_bytes_written = (u_int32_t)(curr_new_var_field_offset_ptr - start_new_var_field_offset_ptr);
*num_data_bytes_written = (uint32_t)(curr_new_var_field_data_ptr - start_new_var_field_data_ptr);
*num_offset_bytes_written = (uint32_t)(curr_new_var_field_offset_ptr - start_new_var_field_offset_ptr);
}
static inline u_int32_t
copy_toku_blob(uchar* to_ptr, uchar* from_ptr, u_int32_t len_bytes, bool skip) {
u_int32_t length = 0;
static inline uint32_t
copy_toku_blob(uchar* to_ptr, uchar* from_ptr, uint32_t len_bytes, bool skip) {
uint32_t length = 0;
if (!skip) {
memcpy(to_ptr, from_ptr, len_bytes);
}
@@ -168,13 +168,13 @@ tokudb_update_fun(
void *set_extra
)
{
u_int32_t max_num_bytes;
u_int32_t num_columns;
uint32_t max_num_bytes;
uint32_t num_columns;
DBT new_val;
u_int32_t num_bytes_left;
u_int32_t num_var_fields_to_copy;
u_int32_t num_data_bytes_written = 0;
u_int32_t num_offset_bytes_written = 0;
uint32_t num_bytes_left;
uint32_t num_var_fields_to_copy;
uint32_t num_data_bytes_written = 0;
uint32_t num_offset_bytes_written = 0;
int error;
memset(&new_val, 0, sizeof(DBT));
uchar operation;
@@ -184,32 +184,32 @@ tokudb_update_fun(
//
// info for pointers into rows
//
u_int32_t old_num_null_bytes;
u_int32_t new_num_null_bytes;
uint32_t old_num_null_bytes;
uint32_t new_num_null_bytes;
uchar old_num_offset_bytes;
uchar new_num_offset_bytes;
u_int32_t old_fixed_field_size;
u_int32_t new_fixed_field_size;
u_int32_t old_len_of_offsets;
u_int32_t new_len_of_offsets;
uint32_t old_fixed_field_size;
uint32_t new_fixed_field_size;
uint32_t old_len_of_offsets;
uint32_t new_len_of_offsets;
uchar* old_fixed_field_ptr = NULL;
uchar* new_fixed_field_ptr = NULL;
u_int32_t curr_old_fixed_offset;
u_int32_t curr_new_fixed_offset;
uint32_t curr_old_fixed_offset;
uint32_t curr_new_fixed_offset;
uchar* old_null_bytes = NULL;
uchar* new_null_bytes = NULL;
u_int32_t curr_old_null_pos;
u_int32_t curr_new_null_pos;
u_int32_t old_null_bits_left;
u_int32_t new_null_bits_left;
u_int32_t overall_null_bits_left;
uint32_t curr_old_null_pos;
uint32_t curr_new_null_pos;
uint32_t old_null_bits_left;
uint32_t new_null_bits_left;
uint32_t overall_null_bits_left;
u_int32_t old_num_var_fields;
u_int32_t new_num_var_fields;
u_int32_t curr_old_num_var_field;
u_int32_t curr_new_num_var_field;
uint32_t old_num_var_fields;
uint32_t new_num_var_fields;
uint32_t curr_old_num_var_field;
uint32_t curr_new_num_var_field;
uchar* old_var_field_offset_ptr = NULL;
uchar* new_var_field_offset_ptr = NULL;
uchar* curr_new_var_field_offset_ptr = NULL;
@@ -217,9 +217,9 @@ tokudb_update_fun(
uchar* new_var_field_data_ptr = NULL;
uchar* curr_new_var_field_data_ptr = NULL;
u_int32_t start_blob_offset;
uint32_t start_blob_offset;
uchar* start_blob_ptr;
u_int32_t num_blob_bytes;
uint32_t num_blob_bytes;
// came across a delete, nothing to update
if (old_val == NULL) {
@@ -234,25 +234,25 @@ tokudb_update_fun(
extra_pos++;
assert(operation == UP_COL_ADD_OR_DROP);
memcpy(&old_num_null_bytes, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
memcpy(&new_num_null_bytes, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
memcpy(&old_num_null_bytes, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
memcpy(&new_num_null_bytes, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
old_num_offset_bytes = extra_pos[0];
extra_pos++;
new_num_offset_bytes = extra_pos[0];
extra_pos++;
memcpy(&old_fixed_field_size, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
memcpy(&new_fixed_field_size, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
memcpy(&old_fixed_field_size, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
memcpy(&new_fixed_field_size, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
memcpy(&old_len_of_offsets, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
memcpy(&new_len_of_offsets, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
memcpy(&old_len_of_offsets, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
memcpy(&new_len_of_offsets, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
max_num_bytes = old_val->size + extra->size + new_len_of_offsets + new_fixed_field_size;
new_val_data = (uchar *)my_malloc(
@@ -283,10 +283,10 @@ tokudb_update_fun(
new_null_bytes = new_val_data;
memcpy(&curr_old_null_pos, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
memcpy(&curr_new_null_pos, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
memcpy(&curr_old_null_pos, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
memcpy(&curr_new_null_pos, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
memcpy(&num_columns, extra_pos, sizeof(num_columns));
extra_pos += sizeof(num_columns);
@@ -294,7 +294,7 @@ tokudb_update_fun(
//
// now go through and apply the change into new_val_data
//
for (u_int32_t i = 0; i < num_columns; i++) {
for (uint32_t i = 0; i < num_columns; i++) {
uchar op_type = extra_pos[0];
bool is_null_default = false;
extra_pos++;
@@ -303,10 +303,10 @@ tokudb_update_fun(
bool nullable = (extra_pos[0] != 0);
extra_pos++;
if (nullable) {
u_int32_t null_bit_position;
memcpy(&null_bit_position, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
u_int32_t num_bits;
uint32_t null_bit_position;
memcpy(&null_bit_position, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
uint32_t num_bits;
if (op_type == COL_DROP) {
assert(curr_old_null_pos <= null_bit_position);
num_bits = null_bit_position - curr_old_null_pos;
@@ -342,13 +342,13 @@ tokudb_update_fun(
uchar col_type = extra_pos[0];
extra_pos++;
if (col_type == COL_FIXED) {
u_int32_t col_offset;
u_int32_t col_size;
u_int32_t num_bytes_to_copy;
memcpy(&col_offset, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
memcpy(&col_size, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
uint32_t col_offset;
uint32_t col_size;
uint32_t num_bytes_to_copy;
memcpy(&col_offset, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
memcpy(&col_size, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
if (op_type == COL_DROP) {
num_bytes_to_copy = col_offset - curr_old_fixed_offset;
@@ -386,9 +386,9 @@ tokudb_update_fun(
}
else if (col_type == COL_VAR) {
u_int32_t var_col_index;
memcpy(&var_col_index, extra_pos, sizeof(u_int32_t));
extra_pos += sizeof(u_int32_t);
uint32_t var_col_index;
memcpy(&var_col_index, extra_pos, sizeof(uint32_t));
extra_pos += sizeof(uint32_t);
if (op_type == COL_DROP) {
num_var_fields_to_copy = var_col_index - curr_old_num_var_field;
}
@@ -428,7 +428,7 @@ tokudb_update_fun(
curr_new_var_field_offset_ptr += new_num_offset_bytes;
}
else {
u_int32_t data_length;
uint32_t data_length;
memcpy(&data_length, extra_pos, sizeof(data_length));
extra_pos += sizeof(data_length);
curr_new_var_field_data_ptr = write_var_field(
@@ -514,9 +514,9 @@ tokudb_update_fun(
// else, there is blob information to process
else {
uchar* len_bytes = NULL;
u_int32_t curr_old_blob = 0;
u_int32_t curr_new_blob = 0;
u_int32_t num_old_blobs = 0;
uint32_t curr_old_blob = 0;
uint32_t curr_new_blob = 0;
uint32_t num_old_blobs = 0;
uchar* curr_old_blob_ptr = start_blob_ptr;
memcpy(&num_old_blobs, extra_pos, sizeof(num_old_blobs));
extra_pos += sizeof(num_old_blobs);
@@ -526,8 +526,8 @@ tokudb_update_fun(
while ((extra_pos - extra_pos_start) < extra->size) {
uchar op_type = extra_pos[0];
extra_pos++;
u_int32_t num_blobs_to_copy = 0;
u_int32_t blob_index;
uint32_t num_blobs_to_copy = 0;
uint32_t blob_index;
memcpy(&blob_index, extra_pos, sizeof(blob_index));
extra_pos += sizeof(blob_index);
assert (op_type == COL_DROP || op_type == COL_ADD);
@@ -537,8 +537,8 @@ tokudb_update_fun(
else {
num_blobs_to_copy = blob_index - curr_new_blob;
}
for (u_int32_t i = 0; i < num_blobs_to_copy; i++) {
u_int32_t num_bytes_written = copy_toku_blob(
for (uint32_t i = 0; i < num_blobs_to_copy; i++) {
uint32_t num_bytes_written = copy_toku_blob(
curr_new_var_field_data_ptr,
curr_old_blob_ptr,
len_bytes[curr_old_blob + i],
@@ -551,7 +551,7 @@ tokudb_update_fun(
curr_new_blob += num_blobs_to_copy;
if (op_type == COL_DROP) {
// skip over blob in row
u_int32_t num_bytes = copy_toku_blob(
uint32_t num_bytes = copy_toku_blob(
NULL,
curr_old_blob_ptr,
len_bytes[curr_old_blob],
@@ -562,9 +562,9 @@ tokudb_update_fun(
}
else {
// copy new data
u_int32_t new_len_bytes = extra_pos[0];
uint32_t new_len_bytes = extra_pos[0];
extra_pos++;
u_int32_t num_bytes = copy_toku_blob(
uint32_t num_bytes = copy_toku_blob(
curr_new_var_field_data_ptr,
extra_pos,
new_len_bytes,

444
storage/tokudb/hatoku_cmp.cc
View File

File diff suppressed because it is too large Load Diff

90
storage/tokudb/hatoku_cmp.h
View File

@@ -47,7 +47,7 @@
// used for queries
typedef struct st_col_pack_info {
u_int32_t col_pack_val; //offset if fixed, pack_index if var
uint32_t col_pack_val; //offset if fixed, pack_index if var
} COL_PACK_INFO;
//
@@ -62,8 +62,8 @@ typedef struct st_col_pack_info {
// To figure out where the blobs start, find the last offset listed (if offsets exist)
//
typedef struct st_multi_col_pack_info {
u_int32_t fixed_field_size; //where the fixed length stuff ends and the offsets for var stuff begins
u_int32_t len_of_offsets; //length of the offset bytes in a packed row
uint32_t fixed_field_size; //where the fixed length stuff ends and the offsets for var stuff begins
uint32_t len_of_offsets; //length of the offset bytes in a packed row
} MULTI_COL_PACK_INFO;
@@ -91,10 +91,10 @@ typedef struct st_key_and_col_info {
// length_bytes[i] is 0
// 'i' shows up in blob_fields
//
u_int16_t* field_lengths; //stores the field lengths of fixed size fields (1<<16 - 1 max),
uint16_t* field_lengths; //stores the field lengths of fixed size fields (1<<16 - 1 max),
uchar* length_bytes; // stores the length of lengths of varchars and varbinaries
u_int32_t* blob_fields; // list of indexes of blob fields,
u_int32_t num_blobs; // number of blobs in the table
uint32_t* blob_fields; // list of indexes of blob fields,
uint32_t num_blobs; // number of blobs in the table
//
// val packing info for all dictionaries. i'th one represents info for i'th dictionary
//
@@ -105,33 +105,33 @@ typedef struct st_key_and_col_info {
// The number of var fields in a val for dictionary i can be evaluated by
// mcp_info[i].len_of_offsets/num_offset_bytes.
//
u_int32_t num_offset_bytes; //number of bytes needed to encode the offset
uint32_t num_offset_bytes; //number of bytes needed to encode the offset
} KEY_AND_COL_INFO;
void get_var_field_info(
u_int32_t* field_len,
u_int32_t* start_offset,
u_int32_t var_field_index,
uint32_t* field_len,
uint32_t* start_offset,
uint32_t var_field_index,
const uchar* var_field_offset_ptr,
u_int32_t num_offset_bytes
uint32_t num_offset_bytes
);
void get_blob_field_info(
u_int32_t* start_offset,
u_int32_t len_of_offsets,
uint32_t* start_offset,
uint32_t len_of_offsets,
const uchar* var_field_data_ptr,
u_int32_t num_offset_bytes
uint32_t num_offset_bytes
);
static inline u_int32_t get_blob_field_len(
static inline uint32_t get_blob_field_len(
const uchar* from_tokudb,
u_int32_t len_bytes
uint32_t len_bytes
)
{
u_int32_t length = 0;
uint32_t length = 0;
switch (len_bytes) {
case (1):
length = (u_int32_t)(*from_tokudb);
length = (uint32_t)(*from_tokudb);
break;
case (2):
length = uint2korr(from_tokudb);
@@ -152,11 +152,11 @@ static inline u_int32_t get_blob_field_len(
static inline const uchar* unpack_toku_field_blob(
uchar *to_mysql,
const uchar* from_tokudb,
u_int32_t len_bytes,
uint32_t len_bytes,
bool skip
)
{
u_int32_t length = 0;
uint32_t length = 0;
const uchar* data_ptr = NULL;
if (!skip) {
memcpy(to_mysql, from_tokudb, len_bytes);
@@ -194,16 +194,16 @@ TOKU_TYPE mysql_to_toku_type (Field* field);
uchar* pack_toku_varbinary_from_desc(
uchar* to_tokudb,
const uchar* from_desc,
u_int32_t key_part_length, //number of bytes to use to encode the length in to_tokudb
u_int32_t field_length //length of field
uint32_t key_part_length, //number of bytes to use to encode the length in to_tokudb
uint32_t field_length //length of field
);
uchar* pack_toku_varstring_from_desc(
uchar* to_tokudb,
const uchar* from_desc,
u_int32_t key_part_length, //number of bytes to use to encode the length in to_tokudb
u_int32_t field_length,
u_int32_t charset_num//length of field
uint32_t key_part_length, //number of bytes to use to encode the length in to_tokudb
uint32_t field_length,
uint32_t charset_num//length of field
);
@@ -211,21 +211,21 @@ uchar* pack_toku_key_field(
uchar* to_tokudb,
uchar* from_mysql,
Field* field,
u_int32_t key_part_length //I really hope this is temporary as I phase out the pack_cmp stuff
uint32_t key_part_length //I really hope this is temporary as I phase out the pack_cmp stuff
);
uchar* pack_key_toku_key_field(
uchar* to_tokudb,
uchar* from_mysql,
Field* field,
u_int32_t key_part_length //I really hope this is temporary as I phase out the pack_cmp stuff
uint32_t key_part_length //I really hope this is temporary as I phase out the pack_cmp stuff
);
uchar* unpack_toku_key_field(
uchar* to_mysql,
uchar* from_tokudb,
Field* field,
u_int32_t key_part_length
uint32_t key_part_length
);
@@ -263,11 +263,11 @@ static inline ulonglong hpk_char_to_num(uchar* val) {
int tokudb_compare_two_keys(
const void* new_key_data,
const u_int32_t new_key_size,
const uint32_t new_key_size,
const void* saved_key_data,
const u_int32_t saved_key_size,
const uint32_t saved_key_size,
const void* row_desc,
const u_int32_t row_desc_size,
const uint32_t row_desc_size,
bool cmp_prefix
);
@@ -286,43 +286,43 @@ int create_toku_key_descriptor(
);
u_int32_t create_toku_main_key_pack_descriptor (
uint32_t create_toku_main_key_pack_descriptor (
uchar* buf
);
u_int32_t get_max_clustering_val_pack_desc_size(
uint32_t get_max_clustering_val_pack_desc_size(
TABLE_SHARE* table_share
);
u_int32_t create_toku_clustering_val_pack_descriptor (
uint32_t create_toku_clustering_val_pack_descriptor (
uchar* buf,
uint pk_index,
TABLE_SHARE* table_share,
KEY_AND_COL_INFO* kc_info,
u_int32_t keynr,
uint32_t keynr,
bool is_clustering
);
static inline bool is_key_clustering(
void* row_desc,
u_int32_t row_desc_size
uint32_t row_desc_size
)
{
return (row_desc_size > 0);
}
u_int32_t pack_clustering_val_from_desc(
uint32_t pack_clustering_val_from_desc(
uchar* buf,
void* row_desc,
u_int32_t row_desc_size,
uint32_t row_desc_size,
const DBT* pk_val
);
u_int32_t get_max_secondary_key_pack_desc_size(
uint32_t get_max_secondary_key_pack_desc_size(
KEY_AND_COL_INFO* kc_info
);
u_int32_t create_toku_secondary_key_pack_descriptor (
uint32_t create_toku_secondary_key_pack_descriptor (
uchar* buf,
bool has_hpk,
uint pk_index,
@@ -335,23 +335,23 @@ u_int32_t create_toku_secondary_key_pack_descriptor (
static inline bool is_key_pk(
void* row_desc,
u_int32_t row_desc_size
uint32_t row_desc_size
)
{
uchar* buf = (uchar *)row_desc;
return buf[0];
}
u_int32_t max_key_size_from_desc(
uint32_t max_key_size_from_desc(
void* row_desc,
u_int32_t row_desc_size
uint32_t row_desc_size
);
u_int32_t pack_key_from_desc(
uint32_t pack_key_from_desc(
uchar* buf,
void* row_desc,
u_int32_t row_desc_size,
uint32_t row_desc_size,
const DBT* pk_key,
const DBT* pk_val
);

2
storage/tokudb/hatoku_defines.h
View File

@@ -209,7 +209,7 @@ static inline void make_name(char *newname, const char *tablename, const char *d
nn += sprintf(nn, "-%s", dictname);
}
static inline void commit_txn(DB_TXN* txn, u_int32_t flags) {
static inline void commit_txn(DB_TXN* txn, uint32_t flags) {
int r;
r = txn->commit(txn, flags);
if (r != 0) {

58
storage/tokudb/hatoku_hton.cc
View File

@@ -46,7 +46,7 @@ static MYSQL_THDVAR_BOOL(commit_sync,
"sync on txn commit",
/* check */ NULL,
/* update */ NULL,
/* default*/ TRUE
/* default*/ true
);
static MYSQL_THDVAR_UINT(pk_insert_mode,
@@ -64,49 +64,49 @@ static MYSQL_THDVAR_BOOL(load_save_space,
"if on, intial loads are slower but take less space",
NULL,
NULL,
FALSE
false
);
static MYSQL_THDVAR_BOOL(disable_slow_alter,
0,
"if on, alter tables that require copy are disabled",
NULL,
NULL,
FALSE
false
);
static MYSQL_THDVAR_BOOL(disable_hot_alter,
0,
"if on, hot alter table is disabled",
NULL,
NULL,
FALSE
false
);
static MYSQL_THDVAR_BOOL(create_index_online,
0,
"if on, create index done online",
NULL,
NULL,
TRUE
true
);
static MYSQL_THDVAR_BOOL(disable_prefetching,
0,
"if on, prefetching disabled",
NULL,
NULL,
FALSE
false
);
static MYSQL_THDVAR_BOOL(prelock_empty,
0,
"Tokudb Prelock Empty Table",
NULL,
NULL,
TRUE
true
);
static MYSQL_THDVAR_BOOL(log_client_errors,
0,
"Tokudb Log Client Errors",
NULL,
NULL,
FALSE
false
);
static MYSQL_THDVAR_UINT(block_size,
0,
@@ -150,7 +150,7 @@ tokudb_checkpoint_lock_update(
const void* save)
{
my_bool* val = (my_bool *) var_ptr;
*val= *(my_bool *) save ? TRUE : FALSE;
*val= *(my_bool *) save ? true : false;
if (*val) {
tokudb_checkpoint_lock(thd);
}
@@ -164,7 +164,7 @@ static MYSQL_THDVAR_BOOL(checkpoint_lock,
"Tokudb Checkpoint Lock",
NULL,
tokudb_checkpoint_lock_update,
FALSE
false
);
static const char *tokudb_row_format_names[] = {
@@ -255,16 +255,16 @@ void toku_hton_assert_fail(const char* expr_as_string, const char * fun, const c
//my_bool tokudb_shared_data = FALSE;
static u_int32_t tokudb_init_flags =
//my_bool tokudb_shared_data = false;
static uint32_t tokudb_init_flags =
DB_CREATE | DB_THREAD | DB_PRIVATE |
DB_INIT_LOCK |
DB_INIT_MPOOL |
DB_INIT_TXN |
DB_INIT_LOG |
DB_RECOVER;
static u_int32_t tokudb_env_flags = 0;
// static u_int32_t tokudb_lock_type = DB_LOCK_DEFAULT;
static uint32_t tokudb_env_flags = 0;
// static uint32_t tokudb_lock_type = DB_LOCK_DEFAULT;
// static ulong tokudb_log_buffer_size = 0;
// static ulong tokudb_log_file_size = 0;
static ulonglong tokudb_cache_size = 0;
@@ -276,9 +276,9 @@ static char *tokudb_log_dir;
// static ulong tokudb_region_size = 0;
// static ulong tokudb_cache_parts = 1;
const char *tokudb_hton_name = "TokuDB";
static u_int32_t tokudb_checkpointing_period;
u_int32_t tokudb_write_status_frequency;
u_int32_t tokudb_read_status_frequency;
static uint32_t tokudb_checkpointing_period;
uint32_t tokudb_write_status_frequency;
uint32_t tokudb_read_status_frequency;
#ifdef TOKUDB_VERSION
char *tokudb_version = (char*) TOKUDB_VERSION;
#else
@@ -444,7 +444,7 @@ static int tokudb_init_func(void *p) {
}
if (tokudb_cache_size) {
DBUG_PRINT("info", ("tokudb_cache_size: %lld\n", tokudb_cache_size));
r = db_env->set_cachesize(db_env, (u_int32_t)(tokudb_cache_size >> 30), (u_int32_t)(tokudb_cache_size % (1024L * 1024L * 1024L)), 1);
r = db_env->set_cachesize(db_env, (uint32_t)(tokudb_cache_size >> 30), (uint32_t)(tokudb_cache_size % (1024L * 1024L * 1024L)), 1);
if (r) {
DBUG_PRINT("info", ("set_cachesize %d\n", r));
goto error;
@@ -462,7 +462,7 @@ static int tokudb_init_func(void *p) {
}
}
u_int32_t gbytes, bytes; int parts;
uint32_t gbytes, bytes; int parts;
r = db_env->get_cachesize(db_env, &gbytes, &bytes, &parts);
if (r == 0)
if (tokudb_debug & TOKUDB_DEBUG_INIT)
@@ -551,7 +551,7 @@ static int tokudb_init_func(void *p) {
//3938: succeeded, set the init status flag and unlock
tokudb_hton_initialized = 1;
rw_unlock(&tokudb_hton_initialized_lock);
DBUG_RETURN(FALSE);
DBUG_RETURN(false);
error:
if (metadata_db) {
@@ -567,7 +567,7 @@ error:
// 3938: failed to initialized, drop the flag and lock
tokudb_hton_initialized = 0;
rw_unlock(&tokudb_hton_initialized_lock);
DBUG_RETURN(TRUE);
DBUG_RETURN(true);
}
static int tokudb_done_func(void *p) {
@@ -637,7 +637,7 @@ bool tokudb_flush_logs(handlerton * hton) {
TOKUDB_DBUG_ENTER("tokudb_flush_logs");
int error;
bool result = 0;
u_int32_t curr_tokudb_checkpointing_period = 0;
uint32_t curr_tokudb_checkpointing_period = 0;
//
// get the current checkpointing period
@@ -780,7 +780,7 @@ void txn_progress_func(TOKU_TXN_PROGRESS progress, void* extra) {
}
static void commit_txn_with_progress(DB_TXN* txn, u_int32_t flags, THD* thd) {
static void commit_txn_with_progress(DB_TXN* txn, uint32_t flags, THD* thd) {
int r;
struct txn_progress_info info;
info.thd = thd;
@@ -805,7 +805,7 @@ static void abort_txn_with_progress(DB_TXN* txn, THD* thd) {
static int tokudb_commit(handlerton * hton, THD * thd, bool all) {
TOKUDB_DBUG_ENTER("tokudb_commit");
DBUG_PRINT("trans", ("ending transaction %s", all ? "all" : "stmt"));
u_int32_t syncflag = THDVAR(thd, commit_sync) ? 0 : DB_TXN_NOSYNC;
uint32_t syncflag = THDVAR(thd, commit_sync) ? 0 : DB_TXN_NOSYNC;
tokudb_trx_data *trx = (tokudb_trx_data *) thd_data_get(thd, hton->slot);
DB_TXN **txn = all ? &trx->all : &trx->stmt;
if (*txn) {
@@ -1059,7 +1059,7 @@ cleanup:
TOKUDB_DBUG_RETURN(error);
}
static int store_dbname_tablename_size(TABLE *table, char *name, u_int64_t size, THD *thd) {
static int store_dbname_tablename_size(TABLE *table, char *name, uint64_t size, THD *thd) {
char *tp = strrchr(name, '/');
assert(tp);
char *tablename = tp + 1;
@@ -1181,7 +1181,7 @@ static int tokudb_get_user_data_size(TABLE *table, THD *thd, bool exact) {
if (!error) {
char* name = (char *)curr_key.data;
char* newname;
u_int64_t curr_num_bytes = 0;
uint64_t curr_num_bytes = 0;
DB_BTREE_STAT64 dict_stats;
error = db_create(&curr_db, db_env, 0);
@@ -1241,14 +1241,14 @@ static int tokudb_get_user_data_size(TABLE *table, THD *thd, bool exact) {
// in this case, we have a hidden primary key, do not
// want to report space taken up by the hidden primary key to the user
//
u_int64_t hpk_space = TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH*dict_stats.bt_ndata;
uint64_t hpk_space = TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH*dict_stats.bt_ndata;
curr_num_bytes = (hpk_space > curr_num_bytes) ? 0 : curr_num_bytes - hpk_space;
}
else {
//
// one infinity byte per key needs to be subtracted
//
u_int64_t inf_byte_space = dict_stats.bt_ndata;
uint64_t inf_byte_space = dict_stats.bt_ndata;
curr_num_bytes = (inf_byte_space > curr_num_bytes) ? 0 : curr_num_bytes - inf_byte_space;
}
@@ -1456,7 +1456,7 @@ static bool tokudb_show_status(handlerton * hton, THD * thd, stat_print_fn * sta
default:
break;
}
return FALSE;
return false;
}
static void tokudb_print_error(const DB_ENV * db_env, const char *db_errpfx, const char *buffer) {

4
storage/tokudb/hatoku_hton.h
View File

@@ -37,7 +37,7 @@ srv_row_format_t get_row_format(THD *thd);
extern HASH tokudb_open_tables;
extern pthread_mutex_t tokudb_mutex;
extern pthread_mutex_t tokudb_meta_mutex;
extern u_int32_t tokudb_write_status_frequency;
extern u_int32_t tokudb_read_status_frequency;
extern uint32_t tokudb_write_status_frequency;
extern uint32_t tokudb_read_status_frequency;
#endif //#ifdef _HATOKU_HTON