Skip to content

M
mariadb
Commit dc97402c authored by Mikael Ronstrom's avatar Mikael Ronstrom
Browse files
Options

Changed all no_ to num_ to avoid strange names like no_list_values which is... 

Changed all no_ to num_ to avoid strange names like no_list_values which is not expected to be number of list values, rather a boolea indicating no list values
parent 3b29941f
Show whitespace changes
Inline Side-by-side
Showing with 500 additions and 450 deletions
mysql-test/r/partition_column.result
View file @ dc97402c
drop table if exists t1;
create table t1 (a int)
partition by list (a)
( partition p0 values in (1),
partition p1 values in (1));
ERROR HY000: Multiple definition of same constant in list partitioning
create table t1 (a int)
partition by list (a)
( partition p0 values in (2, 1),
partition p1 values in (4, NULL, 3));
insert into t1 values (1);
insert into t1 values (2);
insert into t1 values (3);
insert into t1 values (4);
insert into t1 values (NULL);
insert into t1 values (5);
ERROR HY000: Table has no partition for value 5
drop table t1;
create table t1 (a int)
partition by list column_list(a)
( partition p0 values in (column_list(2), column_list(1)),
partition p1 values in (column_list(4), column_list(NULL), column_list(3)));
insert into t1 values (1);
insert into t1 values (2);
insert into t1 values (3);
insert into t1 values (4);
insert into t1 values (NULL);
insert into t1 values (5);
ERROR HY000: Table has no partition for value from column_list
drop table t1;
create table t1 (a int, b char(10), c varchar(25), d datetime)
partition by range column_list(a,b,c,d)
subpartition by hash (to_seconds(d))
......
mysql-test/t/partition_column.test
View file @ dc97402c
......@@ -8,6 +8,38 @@
drop table if exists t1;
--enable_warnings
--error ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR
create table t1 (a int)
partition by list (a)
( partition p0 values in (1),
partition p1 values in (1));
create table t1 (a int)
partition by list (a)
( partition p0 values in (2, 1),
partition p1 values in (4, NULL, 3));
insert into t1 values (1);
insert into t1 values (2);
insert into t1 values (3);
insert into t1 values (4);
insert into t1 values (NULL);
--error ER_NO_PARTITION_FOR_GIVEN_VALUE
insert into t1 values (5);
drop table t1;
create table t1 (a int)
partition by list column_list(a)
( partition p0 values in (column_list(2), column_list(1)),
partition p1 values in (column_list(4), column_list(NULL), column_list(3)));
insert into t1 values (1);
insert into t1 values (2);
insert into t1 values (3);
insert into t1 values (4);
insert into t1 values (NULL);
--error ER_NO_PARTITION_FOR_GIVEN_VALUE
insert into t1 values (5);
drop table t1;
create table t1 (a int, b char(10), c varchar(25), d datetime)
partition by range column_list(a,b,c,d)
subpartition by hash (to_seconds(d))
......
sql/ha_partition.cc
View file @ dc97402c
......@@ -244,7 +244,7 @@ void ha_partition::init_handler_variables()
/*
this allows blackhole to work properly
*/
m_no_locks= 0;
m_num_locks= 0;
#ifdef DONT_HAVE_TO_BE_INITALIZED
m_start_key.flag= 0;
......@@ -579,8 +579,8 @@ int ha_partition::drop_partitions(const char *path)
{
List_iterator<partition_element> part_it(m_part_info->partitions);
char part_name_buff[FN_REFLEN];
uint no_parts= m_part_info->partitions.elements;
uint no_subparts= m_part_info->no_subparts;
uint num_parts= m_part_info->partitions.elements;
uint num_subparts= m_part_info->num_subparts;
uint i= 0;
uint name_variant;
int ret_error;
......@@ -610,7 +610,7 @@ int ha_partition::drop_partitions(const char *path)
do
{
partition_element *sub_elem= sub_it++;
part= i * no_subparts + j;
part= i * num_subparts + j;
create_subpartition_name(part_name_buff, path,
part_elem->partition_name,
sub_elem->partition_name, name_variant);
......@@ -620,7 +620,7 @@ int ha_partition::drop_partitions(const char *path)
error= ret_error;
if (deactivate_ddl_log_entry(sub_elem->log_entry->entry_pos))
error= 1;
} while (++j < no_subparts);
} while (++j < num_subparts);
}
else
{
......@@ -639,7 +639,7 @@ int ha_partition::drop_partitions(const char *path)
else
part_elem->part_state= PART_IS_DROPPED;
}
} while (++i < no_parts);
} while (++i < num_parts);
VOID(sync_ddl_log());
DBUG_RETURN(error);
}
......@@ -670,9 +670,9 @@ int ha_partition::rename_partitions(const char *path)
List_iterator<partition_element> temp_it(m_part_info->temp_partitions);
char part_name_buff[FN_REFLEN];
char norm_name_buff[FN_REFLEN];
uint no_parts= m_part_info->partitions.elements;
uint num_parts= m_part_info->partitions.elements;
uint part_count= 0;
uint no_subparts= m_part_info->no_subparts;
uint num_subparts= m_part_info->num_subparts;
uint i= 0;
uint j= 0;
int error= 0;
......@@ -720,7 +720,7 @@ int ha_partition::rename_partitions(const char *path)
error= 1;
else
sub_elem->log_entry= NULL; /* Indicate success */
} while (++j < no_subparts);
} while (++j < num_subparts);
}
else
{
......@@ -776,7 +776,7 @@ int ha_partition::rename_partitions(const char *path)
do
{
sub_elem= sub_it++;
part= i * no_subparts + j;
part= i * num_subparts + j;
create_subpartition_name(norm_name_buff, path,
part_elem->partition_name,
sub_elem->partition_name,
......@@ -805,7 +805,7 @@ int ha_partition::rename_partitions(const char *path)
error= 1;
else
sub_elem->log_entry= NULL;
} while (++j < no_subparts);
} while (++j < num_subparts);
}
else
{
......@@ -837,7 +837,7 @@ int ha_partition::rename_partitions(const char *path)
part_elem->log_entry= NULL;
}
}
} while (++i < no_parts);
} while (++i < num_parts);
VOID(sync_ddl_log());
DBUG_RETURN(error);
}
......@@ -1047,8 +1047,8 @@ int ha_partition::handle_opt_partitions(THD *thd, HA_CHECK_OPT *check_opt,
uint flag)
{
List_iterator<partition_element> part_it(m_part_info->partitions);
uint no_parts= m_part_info->no_parts;
uint no_subparts= m_part_info->no_subparts;
uint num_parts= m_part_info->num_parts;
uint num_subparts= m_part_info->num_subparts;
uint i= 0;
int error;
DBUG_ENTER("ha_partition::handle_opt_partitions");
......@@ -1072,7 +1072,7 @@ int ha_partition::handle_opt_partitions(THD *thd, HA_CHECK_OPT *check_opt,
do
{
sub_elem= subpart_it++;
part= i * no_subparts + j;
part= i * num_subparts + j;
DBUG_PRINT("info", ("Optimize subpartition %u (%s)",
part, sub_elem->partition_name));
#ifdef NOT_USED
......@@ -1096,7 +1096,7 @@ int ha_partition::handle_opt_partitions(THD *thd, HA_CHECK_OPT *check_opt,
}
DBUG_RETURN(error);
}
} while (++j < no_subparts);
} while (++j < num_subparts);
}
else
{
......@@ -1124,7 +1124,7 @@ int ha_partition::handle_opt_partitions(THD *thd, HA_CHECK_OPT *check_opt,
}
}
}
} while (++i < no_parts);
} while (++i < num_parts);
DBUG_RETURN(FALSE);
}
......@@ -1328,10 +1328,10 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
List_iterator<partition_element> part_it(m_part_info->partitions);
List_iterator <partition_element> t_it(m_part_info->temp_partitions);
char part_name_buff[FN_REFLEN];
uint no_parts= m_part_info->partitions.elements;
uint no_subparts= m_part_info->no_subparts;
uint num_parts= m_part_info->partitions.elements;
uint num_subparts= m_part_info->num_subparts;
uint i= 0;
uint no_remain_partitions, part_count, orig_count;
uint num_remain_partitions, part_count, orig_count;
handler **new_file_array;
int error= 1;
bool first;
......@@ -1347,7 +1347,7 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
part_name_buff)));
m_reorged_parts= 0;
if (!m_part_info->is_sub_partitioned())
no_subparts= 1;
num_subparts= 1;
/*
Step 1:
......@@ -1356,7 +1356,7 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
*/
if (temp_partitions)
{
m_reorged_parts= temp_partitions * no_subparts;
m_reorged_parts= temp_partitions * num_subparts;
}
else
{
......@@ -1366,9 +1366,9 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
if (part_elem->part_state == PART_CHANGED ||
part_elem->part_state == PART_REORGED_DROPPED)
{
m_reorged_parts+= no_subparts;
m_reorged_parts+= num_subparts;
}
} while (++i < no_parts);
} while (++i < num_parts);
}
if (m_reorged_parts &&
!(m_reorged_file= (handler**)sql_calloc(sizeof(handler*)*
......@@ -1383,10 +1383,10 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
Calculate number of partitions after change and allocate space for
their handler references.
*/
no_remain_partitions= 0;
num_remain_partitions= 0;
if (temp_partitions)
{
no_remain_partitions= no_parts * no_subparts;
num_remain_partitions= num_parts * num_subparts;
}
else
{
......@@ -1399,17 +1399,17 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
part_elem->part_state == PART_TO_BE_ADDED ||
part_elem->part_state == PART_CHANGED)
{
no_remain_partitions+= no_subparts;
num_remain_partitions+= num_subparts;
}
} while (++i < no_parts);
} while (++i < num_parts);
}
if (!(new_file_array= (handler**)sql_calloc(sizeof(handler*)*
(2*(no_remain_partitions + 1)))))
(2*(num_remain_partitions + 1)))))
{
mem_alloc_error(sizeof(handler*)*2*(no_remain_partitions+1));
mem_alloc_error(sizeof(handler*)*2*(num_remain_partitions+1));
DBUG_RETURN(ER_OUTOFMEMORY);
}
m_added_file= &new_file_array[no_remain_partitions + 1];
m_added_file= &new_file_array[num_remain_partitions + 1];
/*
Step 3:
......@@ -1428,9 +1428,9 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
part_elem->part_state == PART_REORGED_DROPPED)
{
memcpy((void*)&m_reorged_file[part_count],
(void*)&m_file[i*no_subparts],
sizeof(handler*)*no_subparts);
part_count+= no_subparts;
(void*)&m_file[i*num_subparts],
sizeof(handler*)*num_subparts);
part_count+= num_subparts;
}
else if (first && temp_partitions &&
part_elem->part_state == PART_TO_BE_ADDED)
......@@ -1445,11 +1445,11 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
ones used to be.
*/
first= FALSE;
DBUG_ASSERT(((i*no_subparts) + m_reorged_parts) <= m_file_tot_parts);
memcpy((void*)m_reorged_file, &m_file[i*no_subparts],
DBUG_ASSERT(((i*num_subparts) + m_reorged_parts) <= m_file_tot_parts);
memcpy((void*)m_reorged_file, &m_file[i*num_subparts],
sizeof(handler*)*m_reorged_parts);
}
} while (++i < no_parts);
} while (++i < num_parts);
}
/*
......@@ -1467,11 +1467,11 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
partition_element *part_elem= part_it++;
if (part_elem->part_state == PART_NORMAL)
{
DBUG_ASSERT(orig_count + no_subparts <= m_file_tot_parts);
DBUG_ASSERT(orig_count + num_subparts <= m_file_tot_parts);
memcpy((void*)&new_file_array[part_count], (void*)&m_file[orig_count],
sizeof(handler*)*no_subparts);
part_count+= no_subparts;
orig_count+= no_subparts;
sizeof(handler*)*num_subparts);
part_count+= num_subparts;
orig_count+= num_subparts;
}
else if (part_elem->part_state == PART_CHANGED ||
part_elem->part_state == PART_TO_BE_ADDED)
......@@ -1487,16 +1487,16 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
mem_alloc_error(sizeof(handler));
DBUG_RETURN(ER_OUTOFMEMORY);
}
} while (++j < no_subparts);
} while (++j < num_subparts);
if (part_elem->part_state == PART_CHANGED)
orig_count+= no_subparts;
orig_count+= num_subparts;
else if (temp_partitions && first)
{
orig_count+= (no_subparts * temp_partitions);
orig_count+= (num_subparts * temp_partitions);
first= FALSE;
}
}
} while (++i < no_parts);
} while (++i < num_parts);
first= FALSE;
/*
Step 5:
......@@ -1533,7 +1533,7 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
part_elem->partition_name,
sub_elem->partition_name,
name_variant);
part= i * no_subparts + j;
part= i * num_subparts + j;
DBUG_PRINT("info", ("Add subpartition %s", part_name_buff));
if ((error= prepare_new_partition(table, create_info,
new_file_array[part],
......@@ -1544,7 +1544,7 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
DBUG_RETURN(error);
}
m_added_file[part_count++]= new_file_array[part];
} while (++j < no_subparts);
} while (++j < num_subparts);
}
else
{
......@@ -1563,7 +1563,7 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
m_added_file[part_count++]= new_file_array[i];
}
}
} while (++i < no_parts);
} while (++i < num_parts);
/*
Step 6:
......@@ -1580,7 +1580,7 @@ int ha_partition::change_partitions(HA_CREATE_INFO *create_info,
part_elem->part_state= PART_IS_CHANGED;
else if (part_elem->part_state == PART_REORGED_DROPPED)
part_elem->part_state= PART_TO_BE_DROPPED;
} while (++i < no_parts);
} while (++i < num_parts);
for (i= 0; i < temp_partitions; i++)
{
partition_element *part_elem= t_it++;
......@@ -1621,9 +1621,9 @@ int ha_partition::copy_partitions(ulonglong * const copied,
if (m_part_info->linear_hash_ind)
{
if (m_part_info->part_type == HASH_PARTITION)
set_linear_hash_mask(m_part_info, m_part_info->no_parts);
set_linear_hash_mask(m_part_info, m_part_info->num_parts);
else
set_linear_hash_mask(m_part_info, m_part_info->no_subparts);
set_linear_hash_mask(m_part_info, m_part_info->num_subparts);
}
while (reorg_part < m_reorged_parts)
......@@ -1902,7 +1902,7 @@ partition_element *ha_partition::find_partition_element(uint part_id)
uint curr_part_id= 0;
List_iterator_fast <partition_element> part_it(m_part_info->partitions);
for (i= 0; i < m_part_info->no_parts; i++)
for (i= 0; i < m_part_info->num_parts; i++)
{
partition_element *part_elem;
part_elem= part_it++;
......@@ -1910,7 +1910,7 @@ partition_element *ha_partition::find_partition_element(uint part_id)
{
uint j;
List_iterator_fast <partition_element> sub_it(part_elem->subpartitions);
for (j= 0; j < m_part_info->no_subparts; j++)
for (j= 0; j < m_part_info->num_subparts; j++)
{
part_elem= sub_it++;
if (part_id == curr_part_id++)
......@@ -2031,7 +2031,7 @@ bool ha_partition::create_handler_file(const char *name)
{
partition_element *part_elem, *subpart_elem;
uint i, j, part_name_len, subpart_name_len;
uint tot_partition_words, tot_name_len, no_parts;
uint tot_partition_words, tot_name_len, num_parts;
uint tot_parts= 0;
uint tot_len_words, tot_len_byte, chksum, tot_name_words;
char *name_buffer_ptr;
......@@ -2044,11 +2044,11 @@ bool ha_partition::create_handler_file(const char *name)
List_iterator_fast <partition_element> part_it(m_part_info->partitions);
DBUG_ENTER("create_handler_file");
no_parts= m_part_info->partitions.elements;
DBUG_PRINT("info", ("table name = %s, no_parts = %u", name,
no_parts));
num_parts= m_part_info->partitions.elements;
DBUG_PRINT("info", ("table name = %s, num_parts = %u", name,
num_parts));
tot_name_len= 0;
for (i= 0; i < no_parts; i++)
for (i= 0; i < num_parts; i++)
{
part_elem= part_it++;
if (part_elem->part_state != PART_NORMAL &&
......@@ -2066,7 +2066,7 @@ bool ha_partition::create_handler_file(const char *name)
else
{
List_iterator_fast <partition_element> sub_it(part_elem->subpartitions);
for (j= 0; j < m_part_info->no_subparts; j++)
for (j= 0; j < m_part_info->num_subparts; j++)
{
subpart_elem= sub_it++;
tablename_to_filename(subpart_elem->partition_name,
......@@ -2100,7 +2100,7 @@ bool ha_partition::create_handler_file(const char *name)
engine_array= (file_buffer + 12);
name_buffer_ptr= (char*) (file_buffer + ((4 + tot_partition_words) * 4));
part_it.rewind();
for (i= 0; i < no_parts; i++)
for (i= 0; i < num_parts; i++)
{
part_elem= part_it++;
if (part_elem->part_state != PART_NORMAL &&
......@@ -2118,7 +2118,7 @@ bool ha_partition::create_handler_file(const char *name)
else
{
List_iterator_fast <partition_element> sub_it(part_elem->subpartitions);
for (j= 0; j < m_part_info->no_subparts; j++)
for (j= 0; j < m_part_info->num_subparts; j++)
{
subpart_elem= sub_it++;
tablename_to_filename(part_elem->partition_name, part_name,
......@@ -2254,7 +2254,7 @@ bool ha_partition::new_handlers_from_part_info(MEM_ROOT *mem_root)
}
m_file_tot_parts= m_tot_parts;
bzero((char*) m_file, alloc_len);
DBUG_ASSERT(m_part_info->no_parts > 0);
DBUG_ASSERT(m_part_info->num_parts > 0);
i= 0;
part_count= 0;
......@@ -2267,7 +2267,7 @@ bool ha_partition::new_handlers_from_part_info(MEM_ROOT *mem_root)
part_elem= part_it++;
if (m_is_sub_partitioned)
{
for (j= 0; j < m_part_info->no_subparts; j++)
for (j= 0; j < m_part_info->num_subparts; j++)
{
if (!(m_file[part_count++]= get_new_handler(table_share, mem_root,
part_elem->engine_type)))
......@@ -2284,7 +2284,7 @@ bool ha_partition::new_handlers_from_part_info(MEM_ROOT *mem_root)
DBUG_PRINT("info", ("engine_type: %u",
(uint) ha_legacy_type(part_elem->engine_type)));
}
} while (++i < m_part_info->no_parts);
} while (++i < m_part_info->num_parts);
if (part_elem->engine_type == myisam_hton)
{
DBUG_PRINT("info", ("MyISAM"));
......@@ -2480,7 +2480,7 @@ int ha_partition::open(const char *name, int mode, uint test_if_locked)
if ((error= (*file)->ha_open(table, (const char*) name_buff, mode,
test_if_locked)))
goto err_handler;
m_no_locks+= (*file)->lock_count();
m_num_locks+= (*file)->lock_count();
name_buffer_ptr+= strlen(name_buffer_ptr) + 1;
set_if_bigger(ref_length, ((*file)->ref_length));
/*
......@@ -2820,8 +2820,8 @@ int ha_partition::start_stmt(THD *thd, thr_lock_type lock_type)
uint ha_partition::lock_count() const
{
DBUG_ENTER("ha_partition::lock_count");
DBUG_PRINT("info", ("m_no_locks %d", m_no_locks));
DBUG_RETURN(m_no_locks);
DBUG_PRINT("info", ("m_num_locks %d", m_num_locks));
DBUG_RETURN(m_num_locks);
}
......
sql/ha_partition.h
View file @ dc97402c
......@@ -112,7 +112,7 @@ private:
uint m_reorged_parts; // Number of reorganised parts
uint m_tot_parts; // Total number of partitions;
uint m_no_locks; // For engines like ha_blackhole, which needs no locks
uint m_num_locks; // For engines like ha_blackhole, which needs no locks
uint m_last_part; // Last file that we update,write,read
int m_lock_type; // Remembers type of last
// external_lock
......@@ -239,10 +239,10 @@ public:
size_t pack_frm_len);
virtual int drop_partitions(const char *path);
virtual int rename_partitions(const char *path);
bool get_no_parts(const char *name, uint *no_parts)
bool get_no_parts(const char *name, uint *num_parts)
{
DBUG_ENTER("ha_partition::get_no_parts");
*no_parts= m_tot_parts;
*num_parts= m_tot_parts;
DBUG_RETURN(0);
}
virtual void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share);
......
sql/opt_range.cc
View file @ dc97402c
......@@ -2638,7 +2638,7 @@ typedef struct st_part_prune_param
/* Iterator to be used to obtain the "current" set of used partitions */
PARTITION_ITERATOR part_iter;
/* Initialized bitmap of no_subparts size */
/* Initialized bitmap of num_subparts size */
MY_BITMAP subparts_bitmap;
uchar *cur_min_key;
......@@ -2904,8 +2904,8 @@ static void mark_full_partition_used_no_parts(partition_info* part_info,
static void mark_full_partition_used_with_parts(partition_info *part_info,
uint32 part_id)
{
uint32 start= part_id * part_info->no_subparts;
uint32 end= start + part_info->no_subparts;
uint32 start= part_id * part_info->num_subparts;
uint32 end= start + part_info->num_subparts;
DBUG_ENTER("mark_full_partition_used_with_parts");
for (; start != end; start++)
......@@ -3328,10 +3328,10 @@ int find_used_partitions(PART_PRUNE_PARAM *ppar, SEL_ARG *key_tree)
while ((part_id= ppar->part_iter.get_next(&ppar->part_iter)) !=
NOT_A_PARTITION_ID)
{
for (uint i= 0; i < ppar->part_info->no_subparts; i++)
for (uint i= 0; i < ppar->part_info->num_subparts; i++)
if (bitmap_is_set(&ppar->subparts_bitmap, i))
bitmap_set_bit(&ppar->part_info->used_partitions,
part_id * ppar->part_info->no_subparts + i);
part_id * ppar->part_info->num_subparts + i);
}
goto pop_and_go_right;
}
......@@ -3393,7 +3393,7 @@ int find_used_partitions(PART_PRUNE_PARAM *ppar, SEL_ARG *key_tree)
NOT_A_PARTITION_ID)
{
bitmap_set_bit(&part_info->used_partitions,
part_id * part_info->no_subparts + subpart_id);
part_id * part_info->num_subparts + subpart_id);
}
res= 1; /* Some partitions were marked as used */
goto pop_and_go_right;
......@@ -3541,10 +3541,10 @@ static bool create_partition_index_description(PART_PRUNE_PARAM *ppar)
uint used_part_fields, used_subpart_fields;
used_part_fields= fields_ok_for_partition_index(part_info->part_field_array) ?
part_info->no_part_fields : 0;
part_info->num_part_fields : 0;
used_subpart_fields=
fields_ok_for_partition_index(part_info->subpart_field_array)?
part_info->no_subpart_fields : 0;
part_info->num_subpart_fields : 0;
uint total_parts= used_part_fields + used_subpart_fields;
......@@ -3583,10 +3583,10 @@ static bool create_partition_index_description(PART_PRUNE_PARAM *ppar)
if (ppar->subpart_fields)
{
my_bitmap_map *buf;
uint32 bufsize= bitmap_buffer_size(ppar->part_info->no_subparts);
uint32 bufsize= bitmap_buffer_size(ppar->part_info->num_subparts);
if (!(buf= (my_bitmap_map*) alloc_root(alloc, bufsize)))
return TRUE;
bitmap_init(&ppar->subparts_bitmap, buf, ppar->part_info->no_subparts,
bitmap_init(&ppar->subparts_bitmap, buf, ppar->part_info->num_subparts,
FALSE);
}
range_par->key_parts= key_part;
......
sql/partition_info.cc
View file @ dc97402c
......@@ -75,7 +75,7 @@ partition_info *partition_info::get_clone()
SYNOPSIS
create_default_partition_names()
part_no Partition number for subparts
no_parts Number of partitions
num_parts Number of partitions
start_no Starting partition number
subpart Is it subpartitions
......@@ -91,10 +91,10 @@ partition_info *partition_info::get_clone()
#define MAX_PART_NAME_SIZE 8
char *partition_info::create_default_partition_names(uint part_no,
uint no_parts_arg,
uint num_parts_arg,
uint start_no)
{
char *ptr= (char*) sql_calloc(no_parts_arg*MAX_PART_NAME_SIZE);
char *ptr= (char*) sql_calloc(num_parts_arg*MAX_PART_NAME_SIZE);
char *move_ptr= ptr;
uint i= 0;
DBUG_ENTER("create_default_partition_names");
......@@ -105,11 +105,11 @@ char *partition_info::create_default_partition_names(uint part_no,
{
my_sprintf(move_ptr, (move_ptr,"p%u", (start_no + i)));
move_ptr+=MAX_PART_NAME_SIZE;
} while (++i < no_parts_arg);
} while (++i < num_parts_arg);
}
else
{
mem_alloc_error(no_parts_arg*MAX_PART_NAME_SIZE);
mem_alloc_error(num_parts_arg*MAX_PART_NAME_SIZE);
}
DBUG_RETURN(ptr);
}
......@@ -189,19 +189,19 @@ bool partition_info::set_up_default_partitions(handler *file,
goto end;
}
if ((no_parts == 0) &&
((no_parts= file->get_default_no_partitions(info)) == 0))
if ((num_parts == 0) &&
((num_parts= file->get_default_no_partitions(info)) == 0))
{
my_error(ER_PARTITION_NOT_DEFINED_ERROR, MYF(0), "partitions");
goto end;
}
if (unlikely(no_parts > MAX_PARTITIONS))
if (unlikely(num_parts > MAX_PARTITIONS))
{
my_error(ER_TOO_MANY_PARTITIONS_ERROR, MYF(0));
goto end;
}
if (unlikely((!(default_name= create_default_partition_names(0, no_parts,
if (unlikely((!(default_name= create_default_partition_names(0, num_parts,
start_no)))))
goto end;
i= 0;
......@@ -220,7 +220,7 @@ bool partition_info::set_up_default_partitions(handler *file,
mem_alloc_error(sizeof(partition_element));
goto end;
}
} while (++i < no_parts);
} while (++i < num_parts);
result= FALSE;
end:
DBUG_RETURN(result);
......@@ -259,9 +259,9 @@ bool partition_info::set_up_default_subpartitions(handler *file,
List_iterator<partition_element> part_it(partitions);
DBUG_ENTER("partition_info::set_up_default_subpartitions");
if (no_subparts == 0)
no_subparts= file->get_default_no_partitions(info);
if (unlikely((no_parts * no_subparts) > MAX_PARTITIONS))
if (num_subparts == 0)
num_subparts= file->get_default_no_partitions(info);
if (unlikely((num_parts * num_subparts) > MAX_PARTITIONS))
{
my_error(ER_TOO_MANY_PARTITIONS_ERROR, MYF(0));
goto end;
......@@ -288,8 +288,8 @@ bool partition_info::set_up_default_subpartitions(handler *file,
mem_alloc_error(sizeof(partition_element));
goto end;
}
} while (++j < no_subparts);
} while (++i < no_parts);
} while (++j < num_subparts);
} while (++i < num_parts);
result= FALSE;
end:
DBUG_RETURN(result);
......@@ -520,12 +520,12 @@ bool partition_info::check_engine_mix(handlerton *engine_type,
{
handlerton *old_engine_type= engine_type;
bool first= TRUE;
uint no_parts= partitions.elements;
uint num_parts= partitions.elements;
DBUG_ENTER("partition_info::check_engine_mix");
DBUG_PRINT("info", ("in: engine_type = %s, table_engine_set = %u",
ha_resolve_storage_engine_name(engine_type),
table_engine_set));
if (no_parts)
if (num_parts)
{
List_iterator<partition_element> part_it(partitions);
uint i= 0;
......@@ -538,7 +538,7 @@ bool partition_info::check_engine_mix(handlerton *engine_type,
if (is_sub_partitioned() &&
part_elem->subpartitions.elements)
{
uint no_subparts= part_elem->subpartitions.elements;
uint num_subparts= part_elem->subpartitions.elements;
uint j= 0;
List_iterator<partition_element> sub_it(part_elem->subpartitions);
do
......@@ -550,7 +550,7 @@ bool partition_info::check_engine_mix(handlerton *engine_type,
if (check_engine_condition(sub_elem, table_engine_set,
&engine_type, &first))
goto error;
} while (++j < no_subparts);
} while (++j < num_subparts);
/* ensure that the partition also has correct engine */
if (check_engine_condition(part_elem, table_engine_set,
&engine_type, &first))
......@@ -559,7 +559,7 @@ bool partition_info::check_engine_mix(handlerton *engine_type,
else if (check_engine_condition(part_elem, table_engine_set,
&engine_type, &first))
goto error;
} while (++i < no_parts);
} while (++i < num_parts);
}
DBUG_PRINT("info", ("engine_type = %s",
ha_resolve_storage_engine_name(engine_type)));
......@@ -612,21 +612,21 @@ bool partition_info::check_range_constants(THD *thd)
List_iterator<partition_element> it(partitions);
int result= TRUE;
DBUG_ENTER("partition_info::check_range_constants");
DBUG_PRINT("enter", ("RANGE with %d parts, column_list = %u", no_parts,
DBUG_PRINT("enter", ("RANGE with %d parts, column_list = %u", num_parts,
column_list));
if (column_list)
{
part_column_list_val* loc_range_col_array;
part_column_list_val *current_largest_col_val;
uint no_column_values= part_field_list.elements;
uint size_entries= sizeof(part_column_list_val) * no_column_values;
range_col_array= (part_column_list_val*)sql_calloc(no_parts *
uint num_column_values= part_field_list.elements;
uint size_entries= sizeof(part_column_list_val) * num_column_values;
range_col_array= (part_column_list_val*)sql_calloc(num_parts *
size_entries);
LINT_INIT(current_largest_col_val);
if (unlikely(range_col_array == NULL))
{
mem_alloc_error(no_parts * sizeof(longlong));
mem_alloc_error(num_parts * sizeof(longlong));
goto end;
}
loc_range_col_array= range_col_array;
......@@ -642,7 +642,7 @@ bool partition_info::check_range_constants(THD *thd)
if (fix_column_value_functions(thd, col_val, i))
goto end;
memcpy(loc_range_col_array, (const void*)col_val, size_entries);
loc_range_col_array+= no_column_values;
loc_range_col_array+= num_column_values;
if (!first)
{
if (compare_column_values((const void*)current_largest_col_val,
......@@ -652,7 +652,7 @@ bool partition_info::check_range_constants(THD *thd)
current_largest_col_val= col_val;
}
first= FALSE;
} while (++i < no_parts);
} while (++i < num_parts);
}
else
{
......@@ -663,17 +663,17 @@ bool partition_info::check_range_constants(THD *thd)
LINT_INIT(current_largest);
part_result_type= INT_RESULT;
range_int_array= (longlong*)sql_alloc(no_parts * sizeof(longlong));
range_int_array= (longlong*)sql_alloc(num_parts * sizeof(longlong));
if (unlikely(range_int_array == NULL))
{
mem_alloc_error(no_parts * sizeof(longlong));
mem_alloc_error(num_parts * sizeof(longlong));
goto end;
}
i= 0;
do
{
part_def= it++;
if ((i != (no_parts - 1)) || !defined_max_value)
if ((i != (num_parts - 1)) || !defined_max_value)
{
part_range_value= part_def->range_value;
if (!signed_flag)
......@@ -687,14 +687,14 @@ bool partition_info::check_range_constants(THD *thd)
if (unlikely(current_largest > part_range_value) ||
(unlikely(current_largest == part_range_value) &&
(part_range_value < LONGLONG_MAX ||
i != (no_parts - 1) ||
i != (num_parts - 1) ||
!defined_max_value)))
goto range_not_increasing_error;
}
range_int_array[i]= part_range_value;
current_largest= part_range_value;
first= FALSE;
} while (++i < no_parts);
} while (++i < num_parts);
}
result= FALSE;
end:
......@@ -801,7 +801,7 @@ bool partition_info::fix_column_value_functions(THD *thd,
part_column_list_val *col_val,
uint part_id)
{
uint no_columns= part_field_list.elements;
uint num_columns= part_field_list.elements;
Name_resolution_context *context= &thd->lex->current_select->context;
TABLE_LIST *save_list= context->table_list;
bool result= FALSE;
......@@ -814,7 +814,7 @@ bool partition_info::fix_column_value_functions(THD *thd,
}
context->table_list= 0;
thd->where= "partition function";
for (i= 0; i < no_columns; col_val++, i++)
for (i= 0; i < num_columns; col_val++, i++)
{
Item *column_item= col_val->item_expression;
Field *field= part_field_array[i];
......@@ -885,7 +885,7 @@ end:
bool partition_info::check_list_constants(THD *thd)
{
uint i, size_entries, no_column_values;
uint i, size_entries, num_column_values;
uint list_index= 0;
part_elem_value *list_value;
bool result= TRUE;
......@@ -899,7 +899,7 @@ bool partition_info::check_list_constants(THD *thd)
DBUG_ENTER("partition_info::check_list_constants");
part_result_type= INT_RESULT;
no_list_values= 0;
num_list_values= 0;
/*
We begin by calculating the number of list values that have been
defined in the first step.
......@@ -932,17 +932,17 @@ bool partition_info::check_list_constants(THD *thd)
}
List_iterator<part_elem_value> list_val_it1(part_def->list_val_list);
while (list_val_it1++)
no_list_values++;
} while (++i < no_parts);
num_list_values++;
} while (++i < num_parts);
list_func_it.rewind();
no_column_values= part_field_list.elements;
num_column_values= part_field_list.elements;
size_entries= column_list ?
(no_column_values * sizeof(part_column_list_val)) :
(num_column_values * sizeof(part_column_list_val)) :
sizeof(LIST_PART_ENTRY);
ptr= sql_calloc((no_list_values+1) * size_entries);
ptr= sql_calloc((num_list_values+1) * size_entries);
if (unlikely(ptr == NULL))
{
mem_alloc_error(no_list_values * size_entries);
mem_alloc_error(num_list_values * size_entries);
goto end;
}
if (column_list)
......@@ -952,10 +952,6 @@ bool partition_info::check_list_constants(THD *thd)
list_col_array= (part_column_list_val*)ptr;
compare_func= compare_column_values;
i= 0;
/*
Fix to be able to reuse signed sort functions also for unsigned
partition functions.
*/
do
{
part_def= list_func_it++;
......@@ -968,9 +964,9 @@ bool partition_info::check_list_constants(THD *thd)
DBUG_RETURN(TRUE);
}
memcpy(loc_list_col_array, (const void*)col_val, size_entries);
loc_list_col_array+= no_column_values;
loc_list_col_array+= num_column_values;
}
} while (++i < no_parts);
} while (++i < num_parts);
}
else
{
......@@ -995,24 +991,24 @@ bool partition_info::check_list_constants(THD *thd)
list_array[list_index].list_value= calc_value;
list_array[list_index++].partition_id= i;
}
} while (++i < no_parts);
} while (++i < num_parts);
}
if (fixed && no_list_values)
if (fixed && num_list_values)
{
bool first= TRUE;
/*
list_array and list_col_array are unions, so this works for both
variants of LIST partitioning.
*/
my_qsort((void*)list_array, no_list_values, sizeof(LIST_PART_ENTRY),
my_qsort((void*)list_array, num_list_values, sizeof(LIST_PART_ENTRY),
&list_part_cmp);
i= 0;
LINT_INIT(prev_value);
do
{
DBUG_ASSERT(i < no_list_values);
curr_value= column_list ? (void*)&list_col_array[no_column_values * i] :
DBUG_ASSERT(i < num_list_values);
curr_value= column_list ? (void*)&list_col_array[num_column_values * i] :
(void*)&list_array[i];
if (likely(first || compare_func(curr_value, prev_value)))
{
......@@ -1024,7 +1020,7 @@ bool partition_info::check_list_constants(THD *thd)
my_error(ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR, MYF(0));
goto end;
}
} while (++i < no_list_values);
} while (++i < num_list_values);
}
result= FALSE;
end:
......@@ -1088,7 +1084,7 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type,
}
}
if (unlikely(!is_sub_partitioned() &&
!(use_default_subpartitions && use_default_no_subpartitions)))
!(use_default_subpartitions && use_default_num_subpartitions)))
{
my_error(ER_SUBPARTITION_ERROR, MYF(0));
goto end;
......@@ -1154,8 +1150,8 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type,
i= 0;
{
List_iterator<partition_element> part_it(partitions);
uint no_parts_not_set= 0;
uint prev_no_subparts_not_set= no_subparts + 1;
uint num_parts_not_set= 0;
uint prev_num_subparts_not_set= num_subparts + 1;
do
{
partition_element *part_elem= part_it++;
......@@ -1177,7 +1173,7 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type,
{
if (part_elem->engine_type == NULL)
{
no_parts_not_set++;
num_parts_not_set++;
part_elem->engine_type= default_engine_type;
}
if (check_table_name(part_elem->partition_name,
......@@ -1192,7 +1188,7 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type,
else
{
uint j= 0;
uint no_subparts_not_set= 0;
uint num_subparts_not_set= 0;
List_iterator<partition_element> sub_it(part_elem->subpartitions);
partition_element *sub_elem;
do
......@@ -1211,44 +1207,45 @@ bool partition_info::check_partition_info(THD *thd, handlerton **eng_type,
else
{
sub_elem->engine_type= default_engine_type;
no_subparts_not_set++;
num_subparts_not_set++;
}
}
DBUG_PRINT("info", ("part = %d sub = %d engine = %s", i, j,
ha_resolve_storage_engine_name(sub_elem->engine_type)));
} while (++j < no_subparts);
} while (++j < num_subparts);
if (prev_no_subparts_not_set == (no_subparts + 1) &&
(no_subparts_not_set == 0 || no_subparts_not_set == no_subparts))
prev_no_subparts_not_set= no_subparts_not_set;
if (prev_num_subparts_not_set == (num_subparts + 1) &&
(num_subparts_not_set == 0 ||
num_subparts_not_set == num_subparts))
prev_num_subparts_not_set= num_subparts_not_set;
if (!table_engine_set &&
prev_no_subparts_not_set != no_subparts_not_set)
prev_num_subparts_not_set != num_subparts_not_set)
{
DBUG_PRINT("info", ("no_subparts_not_set = %u no_subparts = %u",
no_subparts_not_set, no_subparts));
DBUG_PRINT("info", ("num_subparts_not_set = %u num_subparts = %u",
num_subparts_not_set, num_subparts));
my_error(ER_MIX_HANDLER_ERROR, MYF(0));
goto end;
}
if (part_elem->engine_type == NULL)
{
if (no_subparts_not_set == 0)
if (num_subparts_not_set == 0)
part_elem->engine_type= sub_elem->engine_type;
else
{
no_parts_not_set++;
num_parts_not_set++;
part_elem->engine_type= default_engine_type;
}
}
}
} while (++i < no_parts);
} while (++i < num_parts);
if (!table_engine_set &&
no_parts_not_set != 0 &&
no_parts_not_set != no_parts)
num_parts_not_set != 0 &&
num_parts_not_set != num_parts)
{
DBUG_PRINT("info", ("no_parts_not_set = %u no_parts = %u",
no_parts_not_set, no_subparts));
DBUG_PRINT("info", ("num_parts_not_set = %u num_parts = %u",
num_parts_not_set, num_subparts));
my_error(ER_MIX_HANDLER_ERROR, MYF(0));
goto end;
}
......
sql/partition_info.h
View file @ dc97402c
......@@ -176,17 +176,17 @@ public:
uint part_func_len;
uint subpart_func_len;
uint no_parts;
uint no_subparts;
uint num_parts;
uint num_subparts;
uint count_curr_subparts;
uint part_error_code;
uint no_list_values;
uint num_list_values;
uint no_part_fields;
uint no_subpart_fields;
uint no_full_part_fields;
uint num_part_fields;
uint num_subpart_fields;
uint num_full_part_fields;
uint has_null_part_id;
/*
......@@ -197,9 +197,9 @@ public:
uint16 linear_hash_mask;
bool use_default_partitions;
bool use_default_no_partitions;
bool use_default_num_partitions;
bool use_default_subpartitions;
bool use_default_no_subpartitions;
bool use_default_num_subpartitions;
bool default_partitions_setup;
bool defined_max_value;
bool list_of_part_fields;
......@@ -233,12 +233,12 @@ public:
part_type(NOT_A_PARTITION), subpart_type(NOT_A_PARTITION),
part_info_len(0), part_state_len(0),
part_func_len(0), subpart_func_len(0),
no_parts(0), no_subparts(0),
num_parts(0), num_subparts(0),
count_curr_subparts(0), part_error_code(0),
no_list_values(0), no_part_fields(0), no_subpart_fields(0),
no_full_part_fields(0), has_null_part_id(0), linear_hash_mask(0),
use_default_partitions(TRUE), use_default_no_partitions(TRUE),
use_default_subpartitions(TRUE), use_default_no_subpartitions(TRUE),
num_list_values(0), num_part_fields(0), num_subpart_fields(0),
num_full_part_fields(0), has_null_part_id(0), linear_hash_mask(0),
use_default_partitions(TRUE), use_default_num_partitions(TRUE),
use_default_subpartitions(TRUE), use_default_num_subpartitions(TRUE),
default_partitions_setup(FALSE), defined_max_value(FALSE),
list_of_part_fields(FALSE), list_of_subpart_fields(FALSE),
linear_hash_ind(FALSE), fixed(FALSE),
......@@ -266,7 +266,7 @@ public:
/* Returns the total number of partitions on the leaf level */
uint get_tot_partitions()
{
return no_parts * (is_sub_partitioned() ? no_subparts : 1);
return num_parts * (is_sub_partitioned() ? num_subparts : 1);
}
bool set_up_defaults_for_partitioning(handler *file, HA_CREATE_INFO *info,
......@@ -289,7 +289,7 @@ private:
bool set_up_default_partitions(handler *file, HA_CREATE_INFO *info,
uint start_no);
bool set_up_default_subpartitions(handler *file, HA_CREATE_INFO *info);
char *create_default_partition_names(uint part_no, uint no_parts,
char *create_default_partition_names(uint part_no, uint num_parts,
uint start_no);
char *create_subpartition_name(uint subpart_no, const char *part_name);
bool has_unique_name(partition_element *element);
......@@ -317,6 +317,6 @@ void init_all_partitions_iterator(partition_info *part_info,
PARTITION_ITERATOR *part_iter)
{
part_iter->part_nums.start= part_iter->part_nums.cur= 0;
part_iter->part_nums.end= part_info->no_parts;
part_iter->part_nums.end= part_info->num_parts;
part_iter->get_next= get_next_partition_id_range;
}
sql/sql_lex.cc
View file @ dc97402c
......@@ -1498,7 +1498,7 @@ Alter_info::Alter_info(const Alter_info &rhs, MEM_ROOT *mem_root)
keys_onoff(rhs.keys_onoff),
tablespace_op(rhs.tablespace_op),
partition_names(rhs.partition_names, mem_root),
no_parts(rhs.no_parts),
num_parts(rhs.num_parts),
change_level(rhs.change_level),
datetime_field(rhs.datetime_field),
error_if_not_empty(rhs.error_if_not_empty)
......
sql/sql_lex.h
View file @ dc97402c
......@@ -893,7 +893,7 @@ public:
enum enum_enable_or_disable keys_onoff;
enum tablespace_op_type tablespace_op;
List<char> partition_names;
uint no_parts;
uint num_parts;
enum_alter_table_change_level change_level;
Create_field *datetime_field;
bool error_if_not_empty;
......@@ -903,7 +903,7 @@ public:
flags(0),
keys_onoff(LEAVE_AS_IS),
tablespace_op(NO_TABLESPACE_OP),
no_parts(0),
num_parts(0),
change_level(ALTER_TABLE_METADATA_ONLY),
datetime_field(NULL),
error_if_not_empty(FALSE)
......@@ -918,7 +918,7 @@ public:
flags= 0;
keys_onoff= LEAVE_AS_IS;
tablespace_op= NO_TABLESPACE_OP;
no_parts= 0;
num_parts= 0;
partition_names.empty();
change_level= ALTER_TABLE_METADATA_ONLY;
datetime_field= 0;
......
sql/sql_partition.cc
View file @ dc97402c
......@@ -202,26 +202,26 @@ bool partition_default_handling(TABLE *table, partition_info *part_info,
{
DBUG_ENTER("partition_default_handling");
if (part_info->use_default_no_partitions)
if (part_info->use_default_num_partitions)
{
if (!is_create_table_ind &&
table->file->get_no_parts(normalized_path, &part_info->no_parts))
table->file->get_no_parts(normalized_path, &part_info->num_parts))
{
DBUG_RETURN(TRUE);
}
}
else if (part_info->is_sub_partitioned() &&
part_info->use_default_no_subpartitions)
part_info->use_default_num_subpartitions)
{
uint no_parts;
uint num_parts;
if (!is_create_table_ind &&
(table->file->get_no_parts(normalized_path, &no_parts)))
(table->file->get_no_parts(normalized_path, &num_parts)))
{
DBUG_RETURN(TRUE);
}
DBUG_ASSERT(part_info->no_parts > 0);
part_info->no_subparts= no_parts / part_info->no_parts;
DBUG_ASSERT((no_parts % part_info->no_parts) == 0);
DBUG_ASSERT(part_info->num_parts > 0);
part_info->num_subparts= num_parts / part_info->num_parts;
DBUG_ASSERT((num_parts % part_info->num_parts) == 0);
}
part_info->set_up_defaults_for_partitioning(table->file,
(ulonglong)0, (uint)0);
......@@ -254,8 +254,8 @@ bool check_reorganise_list(partition_info *new_part_info,
List<char> list_part_names)
{
uint new_count, old_count;
uint no_new_parts= new_part_info->partitions.elements;
uint no_old_parts= old_part_info->partitions.elements;
uint num_new_parts= new_part_info->partitions.elements;
uint num_old_parts= old_part_info->partitions.elements;
List_iterator<partition_element> new_parts_it(new_part_info->partitions);
bool same_part_info= (new_part_info == old_part_info);
DBUG_ENTER("check_reorganise_list");
......@@ -278,8 +278,8 @@ bool check_reorganise_list(partition_info *new_part_info,
if (!is_name_in_list(old_name, list_part_names))
DBUG_RETURN(TRUE);
}
} while (old_count < no_old_parts);
} while (new_count < no_new_parts);
} while (old_count < num_old_parts);
} while (new_count < num_new_parts);
DBUG_RETURN(FALSE);
}
......@@ -454,7 +454,7 @@ static bool set_up_field_array(TABLE *table,
bool is_sub_part)
{
Field **ptr, *field, **field_array;
uint no_fields= 0;
uint num_fields= 0;
uint size_field_array;
uint i= 0;
uint inx;
......@@ -466,9 +466,9 @@ static bool set_up_field_array(TABLE *table,
while ((field= *(ptr++)))
{
if (field->flags & GET_FIXED_FIELDS_FLAG)
no_fields++;
num_fields++;
}
if (no_fields > MAX_REF_PARTS)
if (num_fields > MAX_REF_PARTS)
{
char *ptr;
if (is_sub_part)
......@@ -478,7 +478,7 @@ static bool set_up_field_array(TABLE *table,
my_error(ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR, MYF(0), ptr);
DBUG_RETURN(TRUE);
}
if (no_fields == 0)
if (num_fields == 0)
{
/*
We are using hidden key as partitioning field
......@@ -486,7 +486,7 @@ static bool set_up_field_array(TABLE *table,
DBUG_ASSERT(!is_sub_part);
DBUG_RETURN(result);
}
size_field_array= (no_fields+1)*sizeof(Field*);
size_field_array= (num_fields+1)*sizeof(Field*);
field_array= (Field**)sql_calloc(size_field_array);
if (unlikely(!field_array))
{
......@@ -507,15 +507,15 @@ static bool set_up_field_array(TABLE *table,
List_iterator<char> it(part_info->part_field_list);
char *field_name;
DBUG_ASSERT(no_fields == part_info->part_field_list.elements);
DBUG_ASSERT(num_fields == part_info->part_field_list.elements);
inx= 0;
do
{
field_name= it++;
if (!strcmp(field_name, field->field_name))
break;
} while (++inx < no_fields);
if (inx == no_fields)
} while (++inx < num_fields);
if (inx == num_fields)
{
mem_alloc_error(1);
result= TRUE;
......@@ -543,16 +543,16 @@ static bool set_up_field_array(TABLE *table,
}
}
}
field_array[no_fields]= 0;
field_array[num_fields]= 0;
if (!is_sub_part)
{
part_info->part_field_array= field_array;
part_info->no_part_fields= no_fields;
part_info->num_part_fields= num_fields;
}
else
{
part_info->subpart_field_array= field_array;
part_info->no_subpart_fields= no_fields;
part_info->num_subpart_fields= num_fields;
}
DBUG_RETURN(result);
}
......@@ -591,19 +591,19 @@ static bool create_full_part_field_array(THD *thd, TABLE *table,
if (!part_info->is_sub_partitioned())
{
part_info->full_part_field_array= part_info->part_field_array;
part_info->no_full_part_fields= part_info->no_part_fields;
part_info->num_full_part_fields= part_info->num_part_fields;
}
else
{
Field *field, **field_array;
uint no_part_fields=0, size_field_array;
uint num_part_fields=0, size_field_array;
ptr= table->field;
while ((field= *(ptr++)))
{
if (field->flags & FIELD_IN_PART_FUNC_FLAG)
no_part_fields++;
num_part_fields++;
}
size_field_array= (no_part_fields+1)*sizeof(Field*);
size_field_array= (num_part_fields+1)*sizeof(Field*);
field_array= (Field**)sql_calloc(size_field_array);
if (unlikely(!field_array))
{
......@@ -611,16 +611,16 @@ static bool create_full_part_field_array(THD *thd, TABLE *table,
result= TRUE;
goto end;
}
no_part_fields= 0;
num_part_fields= 0;
ptr= table->field;
while ((field= *(ptr++)))
{
if (field->flags & FIELD_IN_PART_FUNC_FLAG)
field_array[no_part_fields++]= field;
field_array[num_part_fields++]= field;
}
field_array[no_part_fields]=0;
field_array[num_part_fields]=0;
part_info->full_part_field_array= field_array;
part_info->no_full_part_fields= no_part_fields;
part_info->num_full_part_fields= num_part_fields;
}
/*
......@@ -821,11 +821,11 @@ static bool handle_list_of_fields(List_iterator<char> it,
uint primary_key= table->s->primary_key;
if (primary_key != MAX_KEY)
{
uint no_key_parts= table->key_info[primary_key].key_parts, i;
uint num_key_parts= table->key_info[primary_key].key_parts, i;
/*
In the case of an empty list we use primary key as partition key.
*/
for (i= 0; i < no_key_parts; i++)
for (i= 0; i < num_key_parts; i++)
{
Field *field= table->key_info[primary_key].key_part[i].field;
field->flags|= GET_FIXED_FIELDS_FLAG;
......@@ -889,7 +889,7 @@ int check_signed_flag(partition_info *part_info)
error= ER_PARTITION_CONST_DOMAIN_ERROR;
break;
}
} while (++i < part_info->no_parts);
} while (++i < part_info->num_parts);
}
return error;
}
......@@ -946,13 +946,6 @@ static bool fix_fields_part_func(THD *thd, Item* func_expr, TABLE *table,
bool save_use_only_table_context;
DBUG_ENTER("fix_fields_part_func");
if (part_info->fixed)
{
if (!(is_sub_part || (error= check_signed_flag(part_info))))
result= FALSE;
goto end;
}
/*
Set-up the TABLE_LIST object to be a list with a single table
Set the object to zero to create NULL pointers and set alias
......@@ -1217,9 +1210,9 @@ void check_range_capable_PF(TABLE *table)
static bool set_up_partition_bitmap(THD *thd, partition_info *part_info)
{
uint32 *bitmap_buf;
uint bitmap_bits= part_info->no_subparts?
(part_info->no_subparts* part_info->no_parts):
part_info->no_parts;
uint bitmap_bits= part_info->num_subparts?
(part_info->num_subparts* part_info->num_parts):
part_info->num_parts;
uint bitmap_bytes= bitmap_buffer_size(bitmap_bits);
DBUG_ENTER("set_up_partition_bitmap");
......@@ -1437,22 +1430,22 @@ static void set_up_partition_func_pointers(partition_info *part_info)
/*
For linear hashing we need a mask which is on the form 2**n - 1 where
2**n >= no_parts. Thus if no_parts is 6 then mask is 2**3 - 1 = 8 - 1 = 7.
2**n >= num_parts. Thus if num_parts is 6 then mask is 2**3 - 1 = 8 - 1 = 7.
SYNOPSIS
set_linear_hash_mask()
part_info Reference to partitioning data structure
no_parts Number of parts in linear hash partitioning
num_parts Number of parts in linear hash partitioning
RETURN VALUE
NONE
*/
void set_linear_hash_mask(partition_info *part_info, uint no_parts)
void set_linear_hash_mask(partition_info *part_info, uint num_parts)
{
uint mask;
for (mask= 1; mask < no_parts; mask<<=1)
for (mask= 1; mask < num_parts; mask<<=1)
;
part_info->linear_hash_mask= mask - 1;
}
......@@ -1466,7 +1459,7 @@ void set_linear_hash_mask(partition_info *part_info, uint no_parts)
get_part_id_from_linear_hash()
hash_value Hash value calculated by HASH function or KEY function
mask Mask calculated previously by set_linear_hash_mask
no_parts Number of partitions in HASH partitioned part
num_parts Number of partitions in HASH partitioned part
RETURN VALUE
part_id The calculated partition identity (starting at 0)
......@@ -1479,11 +1472,11 @@ void set_linear_hash_mask(partition_info *part_info, uint no_parts)
*/
static uint32 get_part_id_from_linear_hash(longlong hash_value, uint mask,
uint no_parts)
uint num_parts)
{
uint32 part_id= (uint32)(hash_value & mask);
if (part_id >= no_parts)
if (part_id >= num_parts)
{
uint new_mask= ((mask + 1) >> 1) - 1;
part_id= (uint32)(hash_value & new_mask);
......@@ -1627,7 +1620,7 @@ bool fix_partition_func(THD *thd, TABLE *table,
function is correct.
*/
if (part_info->linear_hash_ind)
set_linear_hash_mask(part_info, part_info->no_subparts);
set_linear_hash_mask(part_info, part_info->num_subparts);
if (part_info->list_of_subpart_fields)
{
List_iterator<char> it(part_info->subpart_field_list);
......@@ -1655,7 +1648,7 @@ bool fix_partition_func(THD *thd, TABLE *table,
if (part_info->part_type == HASH_PARTITION)
{
if (part_info->linear_hash_ind)
set_linear_hash_mask(part_info, part_info->no_parts);
set_linear_hash_mask(part_info, part_info->num_parts);
if (part_info->list_of_part_fields)
{
List_iterator<char> it(part_info->part_field_list);
......@@ -1708,7 +1701,7 @@ bool fix_partition_func(THD *thd, TABLE *table,
my_error(ER_INCONSISTENT_PARTITION_INFO_ERROR, MYF(0));
goto end;
}
if (unlikely(part_info->no_parts < 1))
if (unlikely(part_info->num_parts < 1))
{
my_error(ER_PARTITIONS_MUST_BE_DEFINED_ERROR, MYF(0), error_str);
goto end;
......@@ -1852,14 +1845,14 @@ static int add_subpartition_by(File fptr)
static int add_part_field_list(File fptr, List<char> field_list)
{
uint i, no_fields;
uint i, num_fields;
int err= 0;
List_iterator<char> part_it(field_list);
no_fields= field_list.elements;
num_fields= field_list.elements;
i= 0;
err+= add_begin_parenthesis(fptr);
while (i < no_fields)
while (i < num_fields)
{
const char *field_str= part_it++;
String field_string("", 0, system_charset_info);
......@@ -1870,7 +1863,7 @@ static int add_part_field_list(File fptr, List<char> field_list)
strlen(field_str));
thd->options= save_options;
err+= add_string_object(fptr, &field_string);
if (i != (no_fields-1))
if (i != (num_fields-1))
err+= add_comma(fptr);
i++;
}
......@@ -1989,10 +1982,10 @@ static int add_column_list_values(File fptr, partition_info *part_info,
{
int err= 0;
uint i;
uint no_elements= part_info->part_field_list.elements;
uint num_elements= part_info->part_field_list.elements;
err+= add_string(fptr, partition_keywords[PKW_COLUMNS].str);
err+= add_begin_parenthesis(fptr);
for (i= 0; i < no_elements; i++)
for (i= 0; i < num_elements; i++)
{
part_column_list_val *col_val= &list_value->col_val_array[i];
if (col_val->max_value)
......@@ -2029,7 +2022,7 @@ static int add_column_list_values(File fptr, partition_info *part_info,
err+= add_string(fptr,"'");
}
}
if (i != (no_elements - 1))
if (i != (num_elements - 1))
err+= add_string(fptr, comma_str);
}
err+= add_end_parenthesis(fptr);
......@@ -2072,13 +2065,13 @@ static int add_partition_values(File fptr, partition_info *part_info,
uint i;
List_iterator<part_elem_value> list_val_it(p_elem->list_val_list);
err+= add_string(fptr, " VALUES IN ");
uint no_items= p_elem->list_val_list.elements;
uint num_items= p_elem->list_val_list.elements;
err+= add_begin_parenthesis(fptr);
if (p_elem->has_null_value)
{
err+= add_string(fptr, "NULL");
if (no_items == 0)
if (num_items == 0)
{
err+= add_end_parenthesis(fptr);
goto end;
......@@ -2099,9 +2092,9 @@ static int add_partition_values(File fptr, partition_info *part_info,
else
err+= add_uint(fptr, list_value->value);
}
if (i != (no_items-1))
if (i != (num_items-1))
err+= add_comma(fptr);
} while (++i < no_items);
} while (++i < num_items);
err+= add_end_parenthesis(fptr);
}
end:
......@@ -2150,7 +2143,7 @@ char *generate_partition_syntax(partition_info *part_info,
bool use_sql_alloc,
bool show_partition_options)
{
uint i,j, tot_no_parts, no_subparts;
uint i,j, tot_num_parts, num_subparts;
partition_element *part_elem;
ulonglong buffer_length;
char path[FN_REFLEN];
......@@ -2207,12 +2200,12 @@ char *generate_partition_syntax(partition_info *part_info,
err+= add_string(fptr, partition_keywords[PKW_COLUMNS].str);
err+= add_part_field_list(fptr, part_info->part_field_list);
}
if ((!part_info->use_default_no_partitions) &&
if ((!part_info->use_default_num_partitions) &&
part_info->use_default_partitions)
{
err+= add_string(fptr, "\n");
err+= add_string(fptr, "PARTITIONS ");
err+= add_int(fptr, part_info->no_parts);
err+= add_int(fptr, part_info->num_parts);
}
if (part_info->is_sub_partitioned())
{
......@@ -2235,16 +2228,16 @@ char *generate_partition_syntax(partition_info *part_info,
part_info->subpart_func_len);
err+= add_end_parenthesis(fptr);
}
if ((!part_info->use_default_no_subpartitions) &&
if ((!part_info->use_default_num_subpartitions) &&
part_info->use_default_subpartitions)
{
err+= add_string(fptr, "\n");
err+= add_string(fptr, "SUBPARTITIONS ");
err+= add_int(fptr, part_info->no_subparts);
err+= add_int(fptr, part_info->num_subparts);
}
}
tot_no_parts= part_info->partitions.elements;
no_subparts= part_info->no_subparts;
tot_num_parts= part_info->partitions.elements;
num_subparts= part_info->num_subparts;
if (!part_info->use_default_partitions)
{
......@@ -2288,7 +2281,7 @@ char *generate_partition_syntax(partition_info *part_info,
err+= add_name_string(fptr, part_elem->partition_name);
if (show_partition_options)
err+= add_partition_options(fptr, part_elem);
if (j != (no_subparts-1))
if (j != (num_subparts-1))
{
err+= add_comma(fptr);
err+= add_string(fptr, "\n");
......@@ -2297,12 +2290,12 @@ char *generate_partition_syntax(partition_info *part_info,
}
else
err+= add_end_parenthesis(fptr);
} while (++j < no_subparts);
} while (++j < num_subparts);
}
}
if (i == (tot_no_parts-1))
if (i == (tot_num_parts-1))
err+= add_end_parenthesis(fptr);
} while (++i < tot_no_parts);
} while (++i < tot_num_parts);
}
if (err)
goto close_file;
......@@ -2449,14 +2442,14 @@ static uint32 calculate_key_value(Field **field_array)
get_part_id_for_sub()
loc_part_id Local partition id
sub_part_id Subpartition id
no_subparts Number of subparts
num_subparts Number of subparts
*/
inline
static uint32 get_part_id_for_sub(uint32 loc_part_id, uint32 sub_part_id,
uint no_subparts)
uint num_subparts)
{
return (uint32)((loc_part_id * no_subparts) + sub_part_id);
return (uint32)((loc_part_id * num_subparts) + sub_part_id);
}
......@@ -2465,7 +2458,7 @@ static uint32 get_part_id_for_sub(uint32 loc_part_id, uint32 sub_part_id,
SYNOPSIS
get_part_id_hash()
no_parts Number of hash partitions
num_parts Number of hash partitions
part_expr Item tree of hash function
out:part_id The returned partition id
out:func_value Value of hash function
......@@ -2475,7 +2468,7 @@ static uint32 get_part_id_for_sub(uint32 loc_part_id, uint32 sub_part_id,
FALSE Success
*/
static int get_part_id_hash(uint no_parts,
static int get_part_id_hash(uint num_parts,
Item *part_expr,
uint32 *part_id,
longlong *func_value)
......@@ -2486,7 +2479,7 @@ static int get_part_id_hash(uint no_parts,
if (part_val_int(part_expr, func_value))
DBUG_RETURN(HA_ERR_NO_PARTITION_FOUND);
int_hash_id= *func_value % no_parts;
int_hash_id= *func_value % num_parts;
*part_id= int_hash_id < 0 ? (uint32) -int_hash_id : (uint32) int_hash_id;
DBUG_RETURN(FALSE);
......@@ -2500,7 +2493,7 @@ static int get_part_id_hash(uint no_parts,
get_part_id_linear_hash()
part_info A reference to the partition_info struct where all the
desired information is given
no_parts Number of hash partitions
num_parts Number of hash partitions
part_expr Item tree of hash function
out:part_id The returned partition id
out:func_value Value of hash function
......@@ -2511,7 +2504,7 @@ static int get_part_id_hash(uint no_parts,
*/
static int get_part_id_linear_hash(partition_info *part_info,
uint no_parts,
uint num_parts,
Item *part_expr,
uint32 *part_id,
longlong *func_value)
......@@ -2523,7 +2516,7 @@ static int get_part_id_linear_hash(partition_info *part_info,
*part_id= get_part_id_from_linear_hash(*func_value,
part_info->linear_hash_mask,
no_parts);
num_parts);
DBUG_RETURN(FALSE);
}
......@@ -2534,7 +2527,7 @@ static int get_part_id_linear_hash(partition_info *part_info,
SYNOPSIS
get_part_id_key()
field_array Array of fields for PARTTION KEY
no_parts Number of KEY partitions
num_parts Number of KEY partitions
RETURN VALUE
Calculated partition id
......@@ -2542,12 +2535,12 @@ static int get_part_id_linear_hash(partition_info *part_info,
inline
static uint32 get_part_id_key(Field **field_array,
uint no_parts,
uint num_parts,
longlong *func_value)
{
DBUG_ENTER("get_part_id_key");
*func_value= calculate_key_value(field_array);
DBUG_RETURN((uint32) (*func_value % no_parts));
DBUG_RETURN((uint32) (*func_value % num_parts));
}
......@@ -2559,7 +2552,7 @@ static uint32 get_part_id_key(Field **field_array,
part_info A reference to the partition_info struct where all the
desired information is given
field_array Array of fields for PARTTION KEY
no_parts Number of KEY partitions
num_parts Number of KEY partitions
RETURN VALUE
Calculated partition id
......@@ -2568,7 +2561,7 @@ static uint32 get_part_id_key(Field **field_array,
inline
static uint32 get_part_id_linear_key(partition_info *part_info,
Field **field_array,
uint no_parts,
uint num_parts,
longlong *func_value)
{
DBUG_ENTER("get_part_id_linear_key");
......@@ -2576,7 +2569,7 @@ static uint32 get_part_id_linear_key(partition_info *part_info,
*func_value= calculate_key_value(field_array);
DBUG_RETURN(get_part_id_from_linear_hash(*func_value,
part_info->linear_hash_mask,
no_parts));
num_parts));
}
/*
......@@ -2772,17 +2765,17 @@ int get_partition_id_list_col(partition_info *part_info,
longlong *func_value)
{
part_column_list_val *list_col_array= part_info->list_col_array;
uint no_columns= part_info->part_field_list.elements;
uint num_columns= part_info->part_field_list.elements;
int list_index, cmp;
int min_list_index= 0;
int max_list_index= part_info->no_list_values - 1;
int max_list_index= part_info->num_list_values - 1;
DBUG_ENTER("get_partition_id_list_col");
while (max_list_index >= min_list_index)
{
list_index= (max_list_index + min_list_index) >> 1;
cmp= cmp_rec_and_tuple(list_col_array + list_index*no_columns,
no_columns);
cmp= cmp_rec_and_tuple(list_col_array + list_index*num_columns,
num_columns);
if (cmp > 0)
min_list_index= list_index + 1;
else if (cmp < 0)
......@@ -2810,7 +2803,7 @@ int get_partition_id_list(partition_info *part_info,
LIST_PART_ENTRY *list_array= part_info->list_array;
int list_index;
int min_list_index= 0;
int max_list_index= part_info->no_list_values - 1;
int max_list_index= part_info->num_list_values - 1;
longlong part_func_value;
int error= part_val_int(part_info->part_expr, &part_func_value);
longlong list_value;
......@@ -2880,7 +2873,7 @@ notfound:
index idx.
The function returns first number idx, such that
list_array[idx].list_value is NOT contained within the passed interval.
If all array elements are contained, part_info->no_list_values is
If all array elements are contained, part_info->num_list_values is
returned.
NOTE
......@@ -2900,17 +2893,17 @@ uint32 get_partition_id_cols_list_for_endpoint(partition_info *part_info,
uint32 nparts)
{
part_column_list_val *list_col_array= part_info->list_col_array;
uint no_columns= part_info->part_field_list.elements;
uint num_columns= part_info->part_field_list.elements;
int list_index, cmp;
uint min_list_index= 0;
uint max_list_index= part_info->no_list_values - 1;
uint max_list_index= part_info->num_list_values - 1;
bool tailf= !(left_endpoint ^ include_endpoint);
DBUG_ENTER("get_partition_id_cols_list_for_endpoint");
do
{
list_index= (max_list_index + min_list_index) >> 1;
cmp= cmp_rec_and_tuple_prune(list_col_array + list_index*no_columns,
cmp= cmp_rec_and_tuple_prune(list_col_array + list_index*num_columns,
nparts, tailf);
if (cmp > 0)
min_list_index= list_index + 1;
......@@ -2953,7 +2946,7 @@ uint32 get_list_array_idx_for_endpoint(partition_info *part_info,
{
LIST_PART_ENTRY *list_array= part_info->list_array;
uint list_index;
uint min_list_index= 0, max_list_index= part_info->no_list_values - 1;
uint min_list_index= 0, max_list_index= part_info->num_list_values - 1;
longlong list_value;
/* Get the partitioning function value for the endpoint */
longlong part_func_value=
......@@ -2967,7 +2960,7 @@ uint32 get_list_array_idx_for_endpoint(partition_info *part_info,
}
if (unsigned_flag)
part_func_value-= 0x8000000000000000ULL;
DBUG_ASSERT(part_info->no_list_values);
DBUG_ASSERT(part_info->num_list_values);
do
{
list_index= (max_list_index + min_list_index) >> 1;
......@@ -2997,8 +2990,8 @@ int get_partition_id_range_col(partition_info *part_info,
longlong *func_value)
{
part_column_list_val *range_col_array= part_info->range_col_array;
uint no_columns= part_info->part_field_list.elements;
uint max_partition= part_info->no_parts - 1;
uint num_columns= part_info->part_field_list.elements;
uint max_partition= part_info->num_parts - 1;
uint min_part_id= 0;
uint max_part_id= max_partition;
uint loc_part_id;
......@@ -3007,21 +3000,21 @@ int get_partition_id_range_col(partition_info *part_info,
while (max_part_id > min_part_id)
{
loc_part_id= (max_part_id + min_part_id + 1) >> 1;
if (cmp_rec_and_tuple(range_col_array + loc_part_id*no_columns,
no_columns) >= 0)
if (cmp_rec_and_tuple(range_col_array + loc_part_id*num_columns,
num_columns) >= 0)
min_part_id= loc_part_id + 1;
else
max_part_id= loc_part_id - 1;
}
loc_part_id= max_part_id;
if (loc_part_id != max_partition)
if (cmp_rec_and_tuple(range_col_array + loc_part_id*no_columns,
no_columns) >= 0)
if (cmp_rec_and_tuple(range_col_array + loc_part_id*num_columns,
num_columns) >= 0)
loc_part_id++;
*part_id= (uint32)loc_part_id;
if (loc_part_id == max_partition &&
(cmp_rec_and_tuple(range_col_array + loc_part_id*no_columns,
no_columns) >= 0))
(cmp_rec_and_tuple(range_col_array + loc_part_id*num_columns,
num_columns) >= 0))
DBUG_RETURN(HA_ERR_NO_PARTITION_FOUND);
DBUG_PRINT("exit",("partition: %d", *part_id));
......@@ -3035,7 +3028,7 @@ int get_partition_id_range(partition_info *part_info,
longlong *func_value)
{
longlong *range_array= part_info->range_int_array;
uint max_partition= part_info->no_parts - 1;
uint max_partition= part_info->num_parts - 1;
uint min_part_id= 0;
uint max_part_id= max_partition;
uint loc_part_id;
......@@ -3112,7 +3105,7 @@ int get_partition_id_range(partition_info *part_info,
represented by range_int_array[idx] has EMPTY intersection with the
passed interval.
If the interval represented by the last array element has non-empty
intersection with the passed interval, part_info->no_parts is
intersection with the passed interval, part_info->num_parts is
returned.
RETURN
......@@ -3140,7 +3133,7 @@ uint32 get_partition_id_range_for_endpoint(partition_info *part_info,
bool include_endpoint)
{
longlong *range_array= part_info->range_int_array;
uint max_partition= part_info->no_parts - 1;
uint max_partition= part_info->num_parts - 1;
uint min_part_id= 0, max_part_id= max_partition, loc_part_id;
/* Get the partitioning function value for the endpoint */
longlong part_func_value=
......@@ -3205,7 +3198,7 @@ int get_partition_id_hash_nosub(partition_info *part_info,
uint32 *part_id,
longlong *func_value)
{
return get_part_id_hash(part_info->no_parts, part_info->part_expr,
return get_part_id_hash(part_info->num_parts, part_info->part_expr,
part_id, func_value);
}
......@@ -3214,7 +3207,7 @@ int get_partition_id_linear_hash_nosub(partition_info *part_info,
uint32 *part_id,
longlong *func_value)
{
return get_part_id_linear_hash(part_info, part_info->no_parts,
return get_part_id_linear_hash(part_info, part_info->num_parts,
part_info->part_expr, part_id, func_value);
}
......@@ -3224,7 +3217,7 @@ int get_partition_id_key_nosub(partition_info *part_info,
longlong *func_value)
{
*part_id= get_part_id_key(part_info->part_field_array,
part_info->no_parts, func_value);
part_info->num_parts, func_value);
return 0;
}
......@@ -3235,7 +3228,7 @@ int get_partition_id_linear_key_nosub(partition_info *part_info,
{
*part_id= get_part_id_linear_key(part_info,
part_info->part_field_array,
part_info->no_parts, func_value);
part_info->num_parts, func_value);
return 0;
}
......@@ -3245,7 +3238,7 @@ int get_partition_id_with_sub(partition_info *part_info,
longlong *func_value)
{
uint32 loc_part_id, sub_part_id;
uint no_subparts;
uint num_subparts;
int error;
DBUG_ENTER("get_partition_id_with_sub");
......@@ -3255,13 +3248,13 @@ int get_partition_id_with_sub(partition_info *part_info,
{
DBUG_RETURN(error);
}
no_subparts= part_info->no_subparts;
num_subparts= part_info->num_subparts;
if (unlikely((error= part_info->get_subpartition_id(part_info,
&sub_part_id))))
{
DBUG_RETURN(error);
}
*part_id= get_part_id_for_sub(loc_part_id, sub_part_id, no_subparts);
*part_id= get_part_id_for_sub(loc_part_id, sub_part_id, num_subparts);
DBUG_RETURN(0);
}
......@@ -3294,7 +3287,7 @@ int get_partition_id_hash_sub(partition_info *part_info,
uint32 *part_id)
{
longlong func_value;
return get_part_id_hash(part_info->no_subparts, part_info->subpart_expr,
return get_part_id_hash(part_info->num_subparts, part_info->subpart_expr,
part_id, &func_value);
}
......@@ -3303,7 +3296,7 @@ int get_partition_id_linear_hash_sub(partition_info *part_info,
uint32 *part_id)
{
longlong func_value;
return get_part_id_linear_hash(part_info, part_info->no_subparts,
return get_part_id_linear_hash(part_info, part_info->num_subparts,
part_info->subpart_expr, part_id,
&func_value);
}
......@@ -3314,7 +3307,7 @@ int get_partition_id_key_sub(partition_info *part_info,
{
longlong func_value;
*part_id= get_part_id_key(part_info->subpart_field_array,
part_info->no_subparts, &func_value);
part_info->num_subparts, &func_value);
return FALSE;
}
......@@ -3325,7 +3318,7 @@ int get_partition_id_linear_key_sub(partition_info *part_info,
longlong func_value;
*part_id= get_part_id_linear_key(part_info,
part_info->subpart_field_array,
part_info->no_subparts, &func_value);
part_info->num_subparts, &func_value);
return FALSE;
}
......@@ -3624,16 +3617,16 @@ void get_partition_set(const TABLE *table, uchar *buf, const uint index,
const key_range *key_spec, part_id_range *part_spec)
{
partition_info *part_info= table->part_info;
uint no_parts= part_info->get_tot_partitions();
uint num_parts= part_info->get_tot_partitions();
uint i, part_id;
uint sub_part= no_parts;
uint32 part_part= no_parts;
uint sub_part= num_parts;
uint32 part_part= num_parts;
KEY *key_info= NULL;
bool found_part_field= FALSE;
DBUG_ENTER("get_partition_set");
part_spec->start_part= 0;
part_spec->end_part= no_parts - 1;
part_spec->end_part= num_parts - 1;
if ((index < MAX_KEY) &&
key_spec->flag == (uint)HA_READ_KEY_EXACT &&
part_info->some_fields_in_PF.is_set(index))
......@@ -3670,7 +3663,7 @@ void get_partition_set(const TABLE *table, uchar *buf, const uint index,
{
if (get_sub_part_id_from_key(table, buf, key_info, key_spec, &sub_part))
{
part_spec->start_part= no_parts;
part_spec->start_part= num_parts;
DBUG_VOID_RETURN;
}
}
......@@ -3684,7 +3677,7 @@ void get_partition_set(const TABLE *table, uchar *buf, const uint index,
allowed values. Thus it is certain that the result of this
scan will be empty.
*/
part_spec->start_part= no_parts;
part_spec->start_part= num_parts;
DBUG_VOID_RETURN;
}
}
......@@ -3722,7 +3715,7 @@ void get_partition_set(const TABLE *table, uchar *buf, const uint index,
{
if (get_sub_part_id_from_key(table, buf, key_info, key_spec, &sub_part))
{
part_spec->start_part= no_parts;
part_spec->start_part= num_parts;
clear_indicator_in_key_fields(key_info);
DBUG_VOID_RETURN;
}
......@@ -3731,7 +3724,7 @@ void get_partition_set(const TABLE *table, uchar *buf, const uint index,
{
if (get_part_id_from_key(table,buf,key_info,key_spec,&part_part))
{
part_spec->start_part= no_parts;
part_spec->start_part= num_parts;
clear_indicator_in_key_fields(key_info);
DBUG_VOID_RETURN;
}
......@@ -3752,29 +3745,29 @@ void get_partition_set(const TABLE *table, uchar *buf, const uint index,
nothing or we have discovered a range of partitions with possible holes
in it. We need a bitvector to further the work here.
*/
if (!(part_part == no_parts && sub_part == no_parts))
if (!(part_part == num_parts && sub_part == num_parts))
{
/*
We can only arrive here if we are using subpartitioning.
*/
if (part_part != no_parts)
if (part_part != num_parts)
{
/*
We know the top partition and need to scan all underlying
subpartitions. This is a range without holes.
*/
DBUG_ASSERT(sub_part == no_parts);
part_spec->start_part= part_part * part_info->no_subparts;
part_spec->end_part= part_spec->start_part+part_info->no_subparts - 1;
DBUG_ASSERT(sub_part == num_parts);
part_spec->start_part= part_part * part_info->num_subparts;
part_spec->end_part= part_spec->start_part+part_info->num_subparts - 1;
}
else
{
DBUG_ASSERT(sub_part != no_parts);
DBUG_ASSERT(sub_part != num_parts);
part_spec->start_part= sub_part;
part_spec->end_part=sub_part+
(part_info->no_subparts*(part_info->no_parts-1));
for (i= 0, part_id= sub_part; i < part_info->no_parts;
i++, part_id+= part_info->no_subparts)
(part_info->num_subparts*(part_info->num_parts-1));
for (i= 0, part_id= sub_part; i < part_info->num_parts;
i++, part_id+= part_info->num_subparts)
; //Set bit part_id in bit array
}
}
......@@ -4038,9 +4031,9 @@ set_engine_all_partitions(partition_info *part_info,
partition_element *sub_elem= sub_it++;
sub_elem->engine_type= engine_type;
} while (++j < part_info->no_subparts);
} while (++j < part_info->num_subparts);
}
} while (++i < part_info->no_parts);
} while (++i < part_info->num_parts);
}
/*
SYNOPSIS
......@@ -4185,7 +4178,7 @@ uint set_part_state(Alter_info *alter_info, partition_info *tab_part_info,
enum partition_state part_state)
{
uint part_count= 0;
uint no_parts_found= 0;
uint num_parts_found= 0;
List_iterator<partition_element> part_it(tab_part_info->partitions);
do
......@@ -4200,13 +4193,13 @@ uint set_part_state(Alter_info *alter_info, partition_info *tab_part_info,
I.e mark the partition as a partition to be "changed" by
analyzing/optimizing/rebuilding/checking/repairing
*/
no_parts_found++;
num_parts_found++;
part_elem->part_state= part_state;
DBUG_PRINT("info", ("Setting part_state to %u for partition %s",
part_state, part_elem->partition_name));
}
} while (++part_count < tab_part_info->no_parts);
return no_parts_found;
} while (++part_count < tab_part_info->num_parts);
return num_parts_found;
}
......@@ -4287,13 +4280,13 @@ uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
{
uint new_part_no, curr_part_no;
if (tab_part_info->part_type != HASH_PARTITION ||
tab_part_info->use_default_no_partitions)
tab_part_info->use_default_num_partitions)
{
my_error(ER_REORG_NO_PARAM_ERROR, MYF(0));
DBUG_RETURN(TRUE);
}
new_part_no= table->file->get_default_no_partitions(create_info);
curr_part_no= tab_part_info->no_parts;
curr_part_no= tab_part_info->num_parts;
if (new_part_no == curr_part_no)
{
/*
......@@ -4311,7 +4304,7 @@ uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
setting the flag for no default number of partitions
*/
alter_info->flags|= ALTER_ADD_PARTITION;
thd->work_part_info->no_parts= new_part_no - curr_part_no;
thd->work_part_info->num_parts= new_part_no - curr_part_no;
}
else
{
......@@ -4320,7 +4313,7 @@ uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
without setting the flag for no default number of partitions
*/
alter_info->flags|= ALTER_COALESCE_PARTITION;
alter_info->no_parts= curr_part_no - new_part_no;
alter_info->num_parts= curr_part_no - new_part_no;
}
}
if (!(flags= table->file->alter_table_flags(alter_info->flags)))
......@@ -4378,9 +4371,9 @@ uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
partitioning scheme as currently set-up.
Partitions are always added at the end in ADD PARTITION.
*/
uint no_new_partitions= alt_part_info->no_parts;
uint no_orig_partitions= tab_part_info->no_parts;
uint check_total_partitions= no_new_partitions + no_orig_partitions;
uint num_new_partitions= alt_part_info->num_parts;
uint num_orig_partitions= tab_part_info->num_parts;
uint check_total_partitions= num_new_partitions + num_orig_partitions;
uint new_total_partitions= check_total_partitions;
/*
We allow quite a lot of values to be supplied by defaults, however we
......@@ -4397,22 +4390,22 @@ uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
my_error(ER_PARTITION_MAXVALUE_ERROR, MYF(0));
DBUG_RETURN(TRUE);
}
if (no_new_partitions == 0)
if (num_new_partitions == 0)
{
my_error(ER_ADD_PARTITION_NO_NEW_PARTITION, MYF(0));
DBUG_RETURN(TRUE);
}
if (tab_part_info->is_sub_partitioned())
{
if (alt_part_info->no_subparts == 0)
alt_part_info->no_subparts= tab_part_info->no_subparts;
else if (alt_part_info->no_subparts != tab_part_info->no_subparts)
if (alt_part_info->num_subparts == 0)
alt_part_info->num_subparts= tab_part_info->num_subparts;
else if (alt_part_info->num_subparts != tab_part_info->num_subparts)
{
my_error(ER_ADD_PARTITION_SUBPART_ERROR, MYF(0));
DBUG_RETURN(TRUE);
}
check_total_partitions= new_total_partitions*
alt_part_info->no_subparts;
alt_part_info->num_subparts;
}
if (check_total_partitions > MAX_PARTITIONS)
{
......@@ -4423,7 +4416,7 @@ uint prep_alter_part_table(THD *thd, TABLE *table, Alter_info *alter_info,
alt_part_info->subpart_type= tab_part_info->subpart_type;
if (alt_part_info->set_up_defaults_for_partitioning(table->file,
ULL(0),
tab_part_info->no_parts))
tab_part_info->num_parts))
{
DBUG_RETURN(TRUE);
}
......@@ -4498,7 +4491,7 @@ that are reorganised.
uint lower_2n= upper_2n >> 1;
bool all_parts= TRUE;
if (tab_part_info->linear_hash_ind &&
no_new_partitions < upper_2n)
num_new_partitions < upper_2n)
{
/*
An analysis of which parts needs reorganisation shows that it is
......@@ -4507,7 +4500,7 @@ that are reorganised.
onwards it starts again from partition 0 and goes on until
it reaches p(upper_2n - 1). If the last new partition reaches
beyond upper_2n - 1 then the first interval will end with
p(lower_2n - 1) and start with p(no_orig_partitions - lower_2n).
p(lower_2n - 1) and start with p(num_orig_partitions - lower_2n).
If lower_2n partitions are added then p0 to p(lower_2n - 1) will
be reorganised which means that the two interval becomes one
interval at this point. Thus only when adding less than
......@@ -4535,7 +4528,7 @@ that are reorganised.
to TRUE. In this case we don't get into this if-part at all.
*/
all_parts= FALSE;
if (no_new_partitions >= lower_2n)
if (num_new_partitions >= lower_2n)
{
/*
In this case there is only one interval since the two intervals
......@@ -4551,8 +4544,8 @@ that are reorganised.
Also in this case there is only one interval since we are not
going over a 2**n boundary
*/
start_part= no_orig_partitions - lower_2n;
end_part= start_part + (no_new_partitions - 1);
start_part= num_orig_partitions - lower_2n;
end_part= start_part + (num_new_partitions - 1);
}
else
{
......@@ -4561,7 +4554,7 @@ that are reorganised.
new parts that would ensure that the intervals become
overlapping.
*/
start_part= no_orig_partitions - lower_2n;
start_part= num_orig_partitions - lower_2n;
end_part= upper_2n - 1;
start_sec_part= 0;
end_sec_part= new_total_partitions - (upper_2n + 1);
......@@ -4578,7 +4571,7 @@ that are reorganised.
{
p_elem->part_state= PART_CHANGED;
}
} while (++part_no < no_orig_partitions);
} while (++part_no < num_orig_partitions);
}
/*
Need to concatenate the lists here to make it possible to check the
......@@ -4601,8 +4594,8 @@ that are reorganised.
mem_alloc_error(1);
DBUG_RETURN(TRUE);
}
} while (++part_count < no_new_partitions);
tab_part_info->no_parts+= no_new_partitions;
} while (++part_count < num_new_partitions);
tab_part_info->num_parts+= num_new_partitions;
}
/*
If we specify partitions explicitly we don't use defaults anymore.
......@@ -4617,7 +4610,7 @@ that are reorganised.
DBUG_PRINT("info", ("part_info: 0x%lx", (long) tab_part_info));
tab_part_info->use_default_partitions= FALSE;
}
tab_part_info->use_default_no_partitions= FALSE;
tab_part_info->use_default_num_partitions= FALSE;
tab_part_info->is_auto_partitioned= FALSE;
}
}
......@@ -4631,8 +4624,8 @@ that are reorganised.
command to drop the partition failed in the middle.
*/
uint part_count= 0;
uint no_parts_dropped= alter_info->partition_names.elements;
uint no_parts_found= 0;
uint num_parts_dropped= alter_info->partition_names.elements;
uint num_parts_found= 0;
List_iterator<partition_element> part_it(tab_part_info->partitions);
tab_part_info->is_auto_partitioned= FALSE;
......@@ -4642,7 +4635,7 @@ that are reorganised.
my_error(ER_ONLY_ON_RANGE_LIST_PARTITION, MYF(0), "DROP");
DBUG_RETURN(TRUE);
}
if (no_parts_dropped >= tab_part_info->no_parts)
if (num_parts_dropped >= tab_part_info->num_parts)
{
my_error(ER_DROP_LAST_PARTITION, MYF(0));
DBUG_RETURN(TRUE);
......@@ -4656,11 +4649,11 @@ that are reorganised.
/*
Set state to indicate that the partition is to be dropped.
*/
no_parts_found++;
num_parts_found++;
part_elem->part_state= PART_TO_BE_DROPPED;
}
} while (++part_count < tab_part_info->no_parts);
if (no_parts_found != no_parts_dropped)
} while (++part_count < tab_part_info->num_parts);
if (num_parts_found != num_parts_dropped)
{
my_error(ER_DROP_PARTITION_NON_EXISTENT, MYF(0), "DROP");
DBUG_RETURN(TRUE);
......@@ -4670,14 +4663,14 @@ that are reorganised.
my_error(ER_ROW_IS_REFERENCED, MYF(0));
DBUG_RETURN(TRUE);
}
tab_part_info->no_parts-= no_parts_dropped;
tab_part_info->num_parts-= num_parts_dropped;
}
else if (alter_info->flags & ALTER_REBUILD_PARTITION)
{
uint no_parts_found;
uint no_parts_opt= alter_info->partition_names.elements;
no_parts_found= set_part_state(alter_info, tab_part_info, PART_CHANGED);
if (no_parts_found != no_parts_opt &&
uint num_parts_found;
uint num_parts_opt= alter_info->partition_names.elements;
num_parts_found= set_part_state(alter_info, tab_part_info, PART_CHANGED);
if (num_parts_found != num_parts_opt &&
(!(alter_info->flags & ALTER_ALL_PARTITION)))
{
my_error(ER_DROP_PARTITION_NON_EXISTENT, MYF(0), "REBUILD");
......@@ -4691,20 +4684,20 @@ that are reorganised.
}
else if (alter_info->flags & ALTER_COALESCE_PARTITION)
{
uint no_parts_coalesced= alter_info->no_parts;
uint no_parts_remain= tab_part_info->no_parts - no_parts_coalesced;
uint num_parts_coalesced= alter_info->num_parts;
uint num_parts_remain= tab_part_info->num_parts - num_parts_coalesced;
List_iterator<partition_element> part_it(tab_part_info->partitions);
if (tab_part_info->part_type != HASH_PARTITION)
{
my_error(ER_COALESCE_ONLY_ON_HASH_PARTITION, MYF(0));
DBUG_RETURN(TRUE);
}
if (no_parts_coalesced == 0)
if (num_parts_coalesced == 0)
{
my_error(ER_COALESCE_PARTITION_NO_PARTITION, MYF(0));
DBUG_RETURN(TRUE);
}
if (no_parts_coalesced >= tab_part_info->no_parts)
if (num_parts_coalesced >= tab_part_info->num_parts)
{
my_error(ER_DROP_LAST_PARTITION, MYF(0));
DBUG_RETURN(TRUE);
......@@ -4752,21 +4745,21 @@ state of p1.
uint upper_2n= tab_part_info->linear_hash_mask + 1;
uint lower_2n= upper_2n >> 1;
all_parts= FALSE;
if (no_parts_coalesced >= lower_2n)
if (num_parts_coalesced >= lower_2n)
{
all_parts= TRUE;
}
else if (no_parts_remain >= lower_2n)
else if (num_parts_remain >= lower_2n)
{
end_part= tab_part_info->no_parts - (lower_2n + 1);
start_part= no_parts_remain - lower_2n;
end_part= tab_part_info->num_parts - (lower_2n + 1);
start_part= num_parts_remain - lower_2n;
}
else
{
start_part= 0;
end_part= tab_part_info->no_parts - (lower_2n + 1);
end_part= tab_part_info->num_parts - (lower_2n + 1);
end_sec_part= (lower_2n >> 1) - 1;
start_sec_part= end_sec_part - (lower_2n - (no_parts_remain + 1));
start_sec_part= end_sec_part - (lower_2n - (num_parts_remain + 1));
}
}
do
......@@ -4777,19 +4770,19 @@ state of p1.
(part_count >= start_part && part_count <= end_part) ||
(part_count >= start_sec_part && part_count <= end_sec_part)))
p_elem->part_state= PART_CHANGED;
if (++part_count > no_parts_remain)
if (++part_count > num_parts_remain)
{
if (*fast_alter_partition)
p_elem->part_state= PART_REORGED_DROPPED;
else
part_it.remove();
}
} while (part_count < tab_part_info->no_parts);
tab_part_info->no_parts= no_parts_remain;
} while (part_count < tab_part_info->num_parts);
tab_part_info->num_parts= num_parts_remain;
}
if (!(alter_info->flags & ALTER_TABLE_REORG))
{
tab_part_info->use_default_no_partitions= FALSE;
tab_part_info->use_default_num_partitions= FALSE;
tab_part_info->is_auto_partitioned= FALSE;
}
}
......@@ -4806,32 +4799,32 @@ state of p1.
range as those changed from.
This command can be used on RANGE and LIST partitions.
*/
uint no_parts_reorged= alter_info->partition_names.elements;
uint no_parts_new= thd->work_part_info->partitions.elements;
uint num_parts_reorged= alter_info->partition_names.elements;
uint num_parts_new= thd->work_part_info->partitions.elements;
uint check_total_partitions;
tab_part_info->is_auto_partitioned= FALSE;
if (no_parts_reorged > tab_part_info->no_parts)
if (num_parts_reorged > tab_part_info->num_parts)
{
my_error(ER_REORG_PARTITION_NOT_EXIST, MYF(0));
DBUG_RETURN(TRUE);
}
if (!(tab_part_info->part_type == RANGE_PARTITION ||
tab_part_info->part_type == LIST_PARTITION) &&
(no_parts_new != no_parts_reorged))
(num_parts_new != num_parts_reorged))
{
my_error(ER_REORG_HASH_ONLY_ON_SAME_NO, MYF(0));
DBUG_RETURN(TRUE);
}
if (tab_part_info->is_sub_partitioned() &&
alt_part_info->no_subparts &&
alt_part_info->no_subparts != tab_part_info->no_subparts)
alt_part_info->num_subparts &&
alt_part_info->num_subparts != tab_part_info->num_subparts)
{
my_error(ER_PARTITION_WRONG_NO_SUBPART_ERROR, MYF(0));
DBUG_RETURN(TRUE);
}
check_total_partitions= tab_part_info->no_parts + no_parts_new;
check_total_partitions-= no_parts_reorged;
check_total_partitions= tab_part_info->num_parts + num_parts_new;
check_total_partitions-= num_parts_reorged;
if (check_total_partitions > MAX_PARTITIONS)
{
my_error(ER_TOO_MANY_PARTITIONS_ERROR, MYF(0));
......@@ -4839,7 +4832,7 @@ state of p1.
}
alt_part_info->part_type= tab_part_info->part_type;
alt_part_info->subpart_type= tab_part_info->subpart_type;
alt_part_info->no_subparts= tab_part_info->no_subparts;
alt_part_info->num_subparts= tab_part_info->num_subparts;
DBUG_ASSERT(!alt_part_info->use_default_partitions);
if (alt_part_info->set_up_defaults_for_partitioning(table->file,
ULL(0),
......@@ -4936,7 +4929,7 @@ the generated partition syntax in a correct manner.
tab_it.replace(alt_part_elem);
else
tab_it.after(alt_part_elem);
} while (++alt_part_count < no_parts_new);
} while (++alt_part_count < num_parts_new);
}
else if (found_last)
{
......@@ -4951,13 +4944,13 @@ the generated partition syntax in a correct manner.
if (found_first)
found_last= TRUE;
}
} while (++part_count < tab_part_info->no_parts);
if (drop_count != no_parts_reorged)
} while (++part_count < tab_part_info->num_parts);
if (drop_count != num_parts_reorged)
{
my_error(ER_DROP_PARTITION_NON_EXISTENT, MYF(0), "REORGANIZE");
DBUG_RETURN(TRUE);
}
tab_part_info->no_parts= check_total_partitions;
tab_part_info->num_parts= check_total_partitions;
}
}
else
......@@ -4973,7 +4966,7 @@ the generated partition syntax in a correct manner.
!alt_part_info->use_default_subpartitions)
{
tab_part_info->use_default_subpartitions= FALSE;
tab_part_info->use_default_no_subpartitions= FALSE;
tab_part_info->use_default_num_subpartitions= FALSE;
}
if (tab_part_info->check_partition_info(thd, (handlerton**)NULL,
table->file, ULL(0), TRUE))
......@@ -5285,8 +5278,8 @@ static bool mysql_drop_partitions(ALTER_PARTITION_PARAM_TYPE *lpt)
part_it.remove();
remove_count++;
}
} while (++i < part_info->no_parts);
part_info->no_parts-= remove_count;
} while (++i < part_info->num_parts);
part_info->num_parts-= remove_count;
DBUG_RETURN(FALSE);
}
......@@ -5408,7 +5401,7 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
char normal_path[FN_REFLEN];
List_iterator<partition_element> part_it(part_info->partitions);
uint temp_partitions= part_info->temp_partitions.elements;
uint no_elements= part_info->partitions.elements;
uint num_elements= part_info->partitions.elements;
uint i= 0;
DBUG_ENTER("write_log_changed_partitions");
......@@ -5421,7 +5414,7 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
if (part_info->is_sub_partitioned())
{
List_iterator<partition_element> sub_it(part_elem->subpartitions);
uint no_subparts= part_info->no_subparts;
uint num_subparts= part_info->num_subparts;
uint j= 0;
do
{
......@@ -5450,7 +5443,7 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
*next_entry= log_entry->entry_pos;
sub_elem->log_entry= log_entry;
insert_part_info_log_entry_list(part_info, log_entry);
} while (++j < no_subparts);
} while (++j < num_subparts);
}
else
{
......@@ -5478,7 +5471,7 @@ static bool write_log_changed_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
insert_part_info_log_entry_list(part_info, log_entry);
}
}
} while (++i < no_elements);
} while (++i < num_elements);
DBUG_RETURN(FALSE);
}
......@@ -5504,14 +5497,14 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
char tmp_path[FN_LEN];
List_iterator<partition_element> part_it(part_info->partitions);
List_iterator<partition_element> temp_it(part_info->temp_partitions);
uint no_temp_partitions= part_info->temp_partitions.elements;
uint no_elements= part_info->partitions.elements;
uint num_temp_partitions= part_info->temp_partitions.elements;
uint num_elements= part_info->partitions.elements;
DBUG_ENTER("write_log_dropped_partitions");
ddl_log_entry.action_type= DDL_LOG_DELETE_ACTION;
if (temp_list)
no_elements= no_temp_partitions;
while (no_elements--)
num_elements= num_temp_partitions;
while (num_elements--)
{
partition_element *part_elem;
if (temp_list)
......@@ -5525,14 +5518,14 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
uint name_variant;
if (part_elem->part_state == PART_CHANGED ||
(part_elem->part_state == PART_TO_BE_ADDED &&
no_temp_partitions))
num_temp_partitions))
name_variant= TEMP_PART_NAME;
else
name_variant= NORMAL_PART_NAME;
if (part_info->is_sub_partitioned())
{
List_iterator<partition_element> sub_it(part_elem->subpartitions);
uint no_subparts= part_info->no_subparts;
uint num_subparts= part_info->num_subparts;
uint j= 0;
do
{
......@@ -5552,7 +5545,7 @@ static bool write_log_dropped_partitions(ALTER_PARTITION_PARAM_TYPE *lpt,
*next_entry= log_entry->entry_pos;
sub_elem->log_entry= log_entry;
insert_part_info_log_entry_list(part_info, log_entry);
} while (++j < no_subparts);
} while (++j < num_subparts);
}
else
{
......@@ -6705,7 +6698,7 @@ static void set_up_range_analysis_info(partition_info *part_info)
Check if get_part_iter_for_interval_via_walking() can be used for
partitioning
*/
if (part_info->no_part_fields == 1)
if (part_info->num_part_fields == 1)
{
Field *field= part_info->part_field_array[0];
switch (field->type()) {
......@@ -6727,7 +6720,7 @@ setup_subparts:
Check if get_part_iter_for_interval_via_walking() can be used for
subpartitioning
*/
if (part_info->no_subpart_fields == 1)
if (part_info->num_subpart_fields == 1)
{
Field *field= part_info->subpart_field_array[0];
switch (field->type()) {
......@@ -6841,7 +6834,7 @@ typedef uint32 (*get_endpoint_func)(partition_info*, bool left_endpoint,
typedef uint32 (*get_col_endpoint_func)(partition_info*, bool left_endpoint,
bool include_endpoint,
uint32 no_parts);
uint32 num_parts);
/*
Partitioning Interval Analysis: Initialize the iterator for "mapping" case
......@@ -6883,10 +6876,10 @@ uint32 get_partition_id_cols_range_for_endpoint(partition_info *part_info,
bool include_endpoint,
uint32 nparts)
{
uint max_partition= part_info->no_parts - 1;
uint max_partition= part_info->num_parts - 1;
uint min_part_id= 0, max_part_id= max_partition, loc_part_id;
part_column_list_val *range_col_array= part_info->range_col_array;
uint no_columns= part_info->part_field_list.elements;
uint num_columns= part_info->part_field_list.elements;
bool tailf= !(left_endpoint ^ include_endpoint);
DBUG_ENTER("get_partition_id_cols_range_for_endpoint");
......@@ -6894,7 +6887,7 @@ uint32 get_partition_id_cols_range_for_endpoint(partition_info *part_info,
while (max_part_id > min_part_id)
{
loc_part_id= (max_part_id + min_part_id + 1) >> 1;
if (cmp_rec_and_tuple_prune(range_col_array + loc_part_id*no_columns,
if (cmp_rec_and_tuple_prune(range_col_array + loc_part_id*num_columns,
nparts, tailf) >= 0)
min_part_id= loc_part_id + 1;
else
......@@ -6902,7 +6895,7 @@ uint32 get_partition_id_cols_range_for_endpoint(partition_info *part_info,
}
loc_part_id= max_part_id;
if (loc_part_id < max_partition &&
cmp_rec_and_tuple_prune(range_col_array + (loc_part_id+1)*no_columns,
cmp_rec_and_tuple_prune(range_col_array + (loc_part_id+1)*num_columns,
nparts, tailf) >= 0
)
{
......@@ -6910,7 +6903,7 @@ uint32 get_partition_id_cols_range_for_endpoint(partition_info *part_info,
}
if (left_endpoint)
{
if (cmp_rec_and_tuple_prune(range_col_array + loc_part_id*no_columns,
if (cmp_rec_and_tuple_prune(range_col_array + loc_part_id*num_columns,
nparts, tailf) >= 0)
loc_part_id++;
}
......@@ -6919,7 +6912,7 @@ uint32 get_partition_id_cols_range_for_endpoint(partition_info *part_info,
if (loc_part_id < max_partition)
{
int res= cmp_rec_and_tuple_prune(range_col_array +
loc_part_id * no_columns,
loc_part_id * num_columns,
nparts, tailf);
if (!res)
loc_part_id += test(include_endpoint);
......@@ -6969,7 +6962,7 @@ int get_part_iter_for_interval_cols_via_map(partition_info *part_info,
nparts);
}
if (flags & NO_MAX_RANGE)
part_iter->part_nums.end= part_info->no_parts;
part_iter->part_nums.end= part_info->num_parts;
else
{
// Copy from max_value to record
......@@ -7012,7 +7005,7 @@ int get_part_iter_for_interval_via_mapping(partition_info *part_info,
get_endpoint= get_partition_id_range_for_endpoint_charset;
else
get_endpoint= get_partition_id_range_for_endpoint;
max_endpoint_val= part_info->no_parts;
max_endpoint_val= part_info->num_parts;
part_iter->get_next= get_next_partition_id_range;
}
else if (part_info->part_type == LIST_PARTITION)
......@@ -7022,7 +7015,7 @@ int get_part_iter_for_interval_via_mapping(partition_info *part_info,
get_endpoint= get_list_array_idx_for_endpoint_charset;
else
get_endpoint= get_list_array_idx_for_endpoint;
max_endpoint_val= part_info->no_list_values;
max_endpoint_val= part_info->num_list_values;
part_iter->get_next= get_next_partition_id_list;
part_iter->part_info= part_info;
if (max_endpoint_val == 0)
......@@ -7166,13 +7159,13 @@ int get_part_iter_for_interval_via_walking(partition_info *part_info,
if (is_subpart)
{
field= part_info->subpart_field_array[0];
total_parts= part_info->no_subparts;
total_parts= part_info->num_subparts;
get_next_func= get_next_subpartition_via_walking;
}
else
{
field= part_info->part_field_array[0];
total_parts= part_info->no_parts;
total_parts= part_info->num_parts;
get_next_func= get_next_partition_via_walking;
}
......
sql/sql_partition.h
View file @ dc97402c
......@@ -65,7 +65,7 @@ int get_part_for_delete(const uchar *buf, const uchar *rec0,
void prune_partition_set(const TABLE *table, part_id_range *part_spec);
bool check_partition_info(partition_info *part_info,handlerton **eng_type,
TABLE *table, handler *file, HA_CREATE_INFO *info);
void set_linear_hash_mask(partition_info *part_info, uint no_parts);
void set_linear_hash_mask(partition_info *part_info, uint num_parts);
bool fix_partition_func(THD *thd, TABLE *table, bool create_table_ind);
char *generate_partition_syntax(partition_info *part_info,
uint *buf_length, bool use_sql_alloc,
......
sql/sql_table.cc
View file @ dc97402c
......@@ -3700,9 +3700,9 @@ bool mysql_create_table_no_lock(THD *thd,
creates a proper .par file. The current part_info object is
only used to create the frm-file and .par-file.
*/
if (part_info->use_default_no_partitions &&
part_info->no_parts &&
(int)part_info->no_parts !=
if (part_info->use_default_num_partitions &&
part_info->num_parts &&
(int)part_info->num_parts !=
file->get_default_no_partitions(create_info))
{
uint i;
......@@ -3713,13 +3713,13 @@ bool mysql_create_table_no_lock(THD *thd,
(part_it++)->part_state= PART_TO_BE_DROPPED;
}
else if (part_info->is_sub_partitioned() &&
part_info->use_default_no_subpartitions &&
part_info->no_subparts &&
(int)part_info->no_subparts !=
part_info->use_default_num_subpartitions &&
part_info->num_subparts &&
(int)part_info->num_subparts !=
file->get_default_no_partitions(create_info))
{
DBUG_ASSERT(thd->lex->sql_command != SQLCOM_CREATE_TABLE);
part_info->no_subparts= file->get_default_no_partitions(create_info);
part_info->num_subparts= file->get_default_no_partitions(create_info);
}
}
else if (create_info->db_type != engine_type)
......@@ -4531,11 +4531,11 @@ static bool mysql_admin_table(THD* thd, TABLE_LIST* tables,
my_error(ER_PARTITION_MGMT_ON_NONPARTITIONED, MYF(0));
DBUG_RETURN(TRUE);
}
uint no_parts_found;
uint no_parts_opt= alter_info->partition_names.elements;
no_parts_found= set_part_state(alter_info, table->table->part_info,
uint num_parts_found;
uint num_parts_opt= alter_info->partition_names.elements;
num_parts_found= set_part_state(alter_info, table->table->part_info,
PART_CHANGED);
if (no_parts_found != no_parts_opt &&
if (num_parts_found != num_parts_opt &&
(!(alter_info->flags & ALTER_ALL_PARTITION)))
{
char buff[FN_REFLEN + MYSQL_ERRMSG_SIZE];
......
sql/sql_yacc.yy
View file @ dc97402c
......@@ -3810,7 +3810,7 @@ partition_entry:
;
partition:
BY part_type_def opt_no_parts opt_sub_part part_defs
BY part_type_def opt_num_parts opt_sub_part part_defs
;
part_type_def:
......@@ -3895,20 +3895,20 @@ sub_part_func:
;
opt_no_parts:
opt_num_parts:
/* empty */ {}
| PARTITIONS_SYM real_ulong_num
{
uint no_parts= $2;
uint num_parts= $2;
partition_info *part_info= Lex->part_info;
if (no_parts == 0)
if (num_parts == 0)
{
my_error(ER_NO_PARTS_ERROR, MYF(0), "partitions");
MYSQL_YYABORT;
}
part_info->no_parts= no_parts;
part_info->use_default_no_partitions= FALSE;
part_info->num_parts= num_parts;
part_info->use_default_num_partitions= FALSE;
}
;
......@@ -3916,7 +3916,7 @@ opt_sub_part:
/* empty */ {}
| SUBPARTITION_SYM BY opt_linear HASH_SYM sub_part_func
{ Lex->part_info->subpart_type= HASH_PARTITION; }
opt_no_subparts {}
opt_num_subparts {}
| SUBPARTITION_SYM BY opt_linear KEY_SYM
'(' sub_part_field_list ')'
{
......@@ -3924,7 +3924,7 @@ opt_sub_part:
part_info->subpart_type= HASH_PARTITION;
part_info->list_of_subpart_fields= TRUE;
}
opt_no_subparts {}
opt_num_subparts {}
;
sub_part_field_list:
......@@ -3966,19 +3966,19 @@ part_func_expr:
}
;
opt_no_subparts:
opt_num_subparts:
/* empty */ {}
| SUBPARTITIONS_SYM real_ulong_num
{
uint no_parts= $2;
uint num_parts= $2;
LEX *lex= Lex;
if (no_parts == 0)
if (num_parts == 0)
{
my_error(ER_NO_PARTS_ERROR, MYF(0), "subpartitions");
MYSQL_YYABORT;
}
lex->part_info->no_subparts= no_parts;
lex->part_info->use_default_no_subpartitions= FALSE;
lex->part_info->num_subparts= num_parts;
lex->part_info->use_default_num_subpartitions= FALSE;
}
;
......@@ -3989,9 +3989,9 @@ part_defs:
{
partition_info *part_info= Lex->part_info;
uint count_curr_parts= part_info->partitions.elements;
if (part_info->no_parts != 0)
if (part_info->num_parts != 0)
{
if (part_info->no_parts !=
if (part_info->num_parts !=
count_curr_parts)
{
my_parse_error(ER(ER_PARTITION_WRONG_NO_PART_ERROR));
......@@ -4000,7 +4000,7 @@ part_defs:
}
else if (count_curr_parts > 0)
{
part_info->no_parts= count_curr_parts;
part_info->num_parts= count_curr_parts;
}
part_info->count_curr_subparts= 0;
}
......@@ -4026,7 +4026,7 @@ part_definition:
part_info->curr_part_elem= p_elem;
part_info->current_partition= p_elem;
part_info->use_default_partitions= FALSE;
part_info->use_default_no_partitions= FALSE;
part_info->use_default_num_partitions= FALSE;
}
part_name
opt_part_values
......@@ -4338,7 +4338,7 @@ opt_sub_partition:
/* empty */
{
partition_info *part_info= Lex->part_info;
if (part_info->no_subparts != 0 &&
if (part_info->num_subparts != 0 &&
!part_info->use_default_subpartitions)
{
/*
......@@ -4352,9 +4352,9 @@ opt_sub_partition:
| '(' sub_part_list ')'
{
partition_info *part_info= Lex->part_info;
if (part_info->no_subparts != 0)
if (part_info->num_subparts != 0)
{
if (part_info->no_subparts !=
if (part_info->num_subparts !=
part_info->count_curr_subparts)
{
my_parse_error(ER(ER_PARTITION_WRONG_NO_SUBPART_ERROR));
......@@ -4368,7 +4368,7 @@ opt_sub_partition:
my_parse_error(ER(ER_PARTITION_WRONG_NO_SUBPART_ERROR));
MYSQL_YYABORT;
}
part_info->no_subparts= part_info->count_curr_subparts;
part_info->num_subparts= part_info->count_curr_subparts;
}
part_info->count_curr_subparts= 0;
}
......@@ -4410,7 +4410,7 @@ sub_part_definition:
}
part_info->curr_part_elem= sub_p_elem;
part_info->use_default_subpartitions= FALSE;
part_info->use_default_no_subpartitions= FALSE;
part_info->use_default_num_subpartitions= FALSE;
part_info->count_curr_subparts++;
}
sub_name opt_part_options {}
......@@ -5850,7 +5850,7 @@ alter_commands:
LEX *lex= Lex;
lex->alter_info.flags|= ALTER_COALESCE_PARTITION;
lex->no_write_to_binlog= $3;
lex->alter_info.no_parts= $4;
lex->alter_info.num_parts= $4;
}
| reorg_partition_rule
;
......@@ -5892,12 +5892,11 @@ add_part_extra:
| '(' part_def_list ')'
{
LEX *lex= Lex;
lex->part_info->no_parts= lex->part_info->partitions.elements;
lex->part_info->num_parts= lex->part_info->partitions.elements;
}
| PARTITIONS_SYM real_ulong_num
{
LEX *lex= Lex;
lex->part_info->no_parts= $2;
Lex->part_info->num_parts= $2;
}
;
......@@ -5928,7 +5927,7 @@ reorg_parts_rule:
INTO '(' part_def_list ')'
{
partition_info *part_info= Lex->part_info;
part_info->no_parts= part_info->partitions.elements;
part_info->num_parts= part_info->partitions.elements;
}
;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7