BUG#15408: Partitions: subpartition names are not unique

Also, moved some of the code out of handler.h and into partition specific files for better 
separation.
Also, moved some of the C funcs into partition_info as formal C++ methods


mysql-test/r/partition_mgm_err.result:
  result block for test of bug # 15408
mysql-test/t/partition_mgm_err.test:
  test for duplicate subpartition names
sql/Makefile.am:
  adding sql_partition.h, partition_info.cpp, partition_info.h, and partition_element.h to the makefile
sql/ha_partition.cc:
  using the new members of partition_info
sql/ha_partition.h:
  using the new members of partition_info
sql/handler.h:
  moved this code into sql_partition.h
sql/mysql_priv.h:
  including sql_partition.h also now
sql/opt_range.cc:
  using the new members of partition_info
sql/sql_partition.cc:
  moved some of the functions out and into the partition_info class
  using the new members of partition_info
sql/sql_show.cc:
  using the new members of partition_info
win/cmakefiles/sql:
  added partition_info.cpp to the sql cmake file
sql/partition_element.h:
  New BitKeeper file ``sql/partition_element.h''
sql/partition_info.h:
  New BitKeeper file ``sql/partition_info.h''
sql/sql_partition.h:
  New BitKeeper file ``sql/sql_partition.h''

1 files changed, 295 insertions, 0 deletions

diff --git a/sql/partition_info.h b/sql/partition_info.h
new file mode 100644
index 00000000000..94bafbac7a9
--- /dev/null
+++ b/sql/partition_info.h
@@ -0,0 +1,295 @@
+/* Copyright (C) 2000,2004 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+   
+#ifdef USE_PRAGMA_INTERFACE
+#pragma interface			/* gcc class implementation */
+#endif
+
+#include "partition_element.h"
+
+class partition_info;
+
+/* Some function typedefs */
+typedef int (*get_part_id_func)(partition_info *part_info,
+                                 uint32 *part_id,
+                                 longlong *func_value);
+typedef uint32 (*get_subpart_id_func)(partition_info *part_info);
+
+
+
+class partition_info : public Sql_alloc
+{
+public:
+  /*
+   * Here comes a set of definitions needed for partitioned table handlers.
+   */
+  List<partition_element> partitions;
+  List<partition_element> temp_partitions;
+
+  List<char> part_field_list;
+  List<char> subpart_field_list;
+  
+  /* 
+    If there is no subpartitioning, use only this func to get partition ids.
+    If there is subpartitioning, use the this func to get partition id when
+    you have both partition and subpartition fields.
+  */
+  get_part_id_func get_partition_id;
+
+  /* Get partition id when we don't have subpartition fields */
+  get_part_id_func get_part_partition_id;
+
+  /* 
+    Get subpartition id when we have don't have partition fields by we do
+    have subpartition ids.
+    Mikael said that for given constant tuple 
+    {subpart_field1, ..., subpart_fieldN} the subpartition id will be the
+    same in all subpartitions
+  */
+  get_subpart_id_func get_subpartition_id;
+ 
+  /* NULL-terminated array of fields used in partitioned expression */
+  Field **part_field_array;
+  /* NULL-terminated array of fields used in subpartitioned expression */
+  Field **subpart_field_array;
+
+  /* 
+    Array of all fields used in partition and subpartition expression,
+    without duplicates, NULL-terminated.
+  */
+  Field **full_part_field_array;
+
+  Item *part_expr;
+  Item *subpart_expr;
+
+  Item *item_free_list;
+  
+  /* 
+    A bitmap of partitions used by the current query. 
+    Usage pattern:
+    * The handler->extra(HA_EXTRA_RESET) call at query start/end sets all
+      partitions to be unused.
+    * Before index/rnd_init(), partition pruning code sets the bits for used
+      partitions.
+  */
+  MY_BITMAP used_partitions;
+
+  union {
+    longlong *range_int_array;
+    LIST_PART_ENTRY *list_array;
+  };
+  
+  /********************************************
+   * INTERVAL ANALYSIS
+   ********************************************/
+  /*
+    Partitioning interval analysis function for partitioning, or NULL if 
+    interval analysis is not supported for this kind of partitioning.
+  */
+  get_partitions_in_range_iter get_part_iter_for_interval;
+  /*
+    Partitioning interval analysis function for subpartitioning, or NULL if
+    interval analysis is not supported for this kind of partitioning.
+  */
+  get_partitions_in_range_iter get_subpart_iter_for_interval;
+  
+  /*
+    Valid iff
+    get_part_iter_for_interval=get_part_iter_for_interval_via_walking:
+      controls how we'll process "field < C" and "field > C" intervals.
+      If the partitioning function F is strictly increasing, then for any x, y
+      "x < y" => "F(x) < F(y)" (*), i.e. when we get interval "field < C" 
+      we can perform partition pruning on the equivalent "F(field) < F(C)".
+
+      If the partitioning function not strictly increasing (it is simply
+      increasing), then instead of (*) we get "x < y" => "F(x) <= F(y)"
+      i.e. for interval "field < C" we can perform partition pruning for
+      "F(field) <= F(C)".
+  */
+  bool range_analysis_include_bounds;
+  /********************************************
+   * INTERVAL ANALYSIS ENDS 
+   ********************************************/
+  
+  char* part_info_string;
+
+  char *part_func_string;
+  char *subpart_func_string;
+
+  uchar *part_state;
+
+  partition_element *curr_part_elem;
+  partition_element *current_partition;
+  /*
+    These key_map's are used for Partitioning to enable quick decisions
+    on whether we can derive more information about which partition to
+    scan just by looking at what index is used.
+  */
+  key_map all_fields_in_PF, all_fields_in_PPF, all_fields_in_SPF;
+  key_map some_fields_in_PF;
+
+  handlerton *default_engine_type;
+  Item_result part_result_type;
+  partition_type part_type;
+  partition_type subpart_type;
+
+  uint part_info_len;
+  uint part_state_len;
+  uint part_func_len;
+  uint subpart_func_len;
+
+  uint no_parts;
+  uint no_subparts;
+  uint count_curr_subparts;
+
+  uint part_error_code;
+
+  uint no_list_values;
+
+  uint no_part_fields;
+  uint no_subpart_fields;
+  uint no_full_part_fields;
+
+  /*
+    This variable is used to calculate the partition id when using
+    LINEAR KEY/HASH. This functionality is kept in the MySQL Server
+    but mainly of use to handlers supporting partitioning.
+  */
+  uint16 linear_hash_mask;
+
+  bool use_default_partitions;
+  bool use_default_no_partitions;
+  bool use_default_subpartitions;
+  bool use_default_no_subpartitions;
+  bool default_partitions_setup;
+  bool defined_max_value;
+  bool list_of_part_fields;
+  bool list_of_subpart_fields;
+  bool linear_hash_ind;
+  bool fixed;
+  bool from_openfrm;
+
+  partition_info()
+  : get_partition_id(NULL), get_part_partition_id(NULL),
+    get_subpartition_id(NULL),
+    part_field_array(NULL), subpart_field_array(NULL),
+    full_part_field_array(NULL),
+    part_expr(NULL), subpart_expr(NULL), item_free_list(NULL),
+    list_array(NULL),
+    part_info_string(NULL),
+    part_func_string(NULL), subpart_func_string(NULL),
+    part_state(NULL),
+    curr_part_elem(NULL), current_partition(NULL),
+    default_engine_type(NULL),
+    part_result_type(INT_RESULT),
+    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),
+    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), linear_hash_mask(0),
+    use_default_partitions(TRUE),
+    use_default_no_partitions(TRUE),
+    use_default_subpartitions(TRUE),
+    use_default_no_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),
+    from_openfrm(FALSE)
+  {
+    all_fields_in_PF.clear_all();
+    all_fields_in_PPF.clear_all();
+    all_fields_in_SPF.clear_all();
+    some_fields_in_PF.clear_all();
+    partitions.empty();
+    temp_partitions.empty();
+    part_field_list.empty();
+    subpart_field_list.empty();
+  }
+  ~partition_info() {}
+  
+  bool is_sub_partitioned();
+  uint get_tot_partitions();
+  bool set_up_defaults_for_partitioning(handler *file, ulonglong max_rows, 
+                                        uint start_no);
+  char *has_unique_names();
+private:
+  bool set_up_default_partitions(handler *file, ulonglong max_rows,
+                                 uint start_no);
+  bool set_up_default_subpartitions(handler *file, ulonglong max_rows);
+  char *create_default_partition_names(uint part_no, uint no_parts, 
+                                       uint start_no, bool is_subpart);
+  bool has_unique_name(partition_element *element);                                          
+};
+
+/*
+  Answers the question if subpartitioning is used for a certain table
+  SYNOPSIS
+    is_sub_partitioned()
+    part_info          A reference to the partition_info struct
+  RETURN VALUE
+    Returns true if subpartitioning used and false otherwise
+  DESCRIPTION
+    A routine to check for subpartitioning for improved readability of code
+*/
+inline
+bool partition_info::is_sub_partitioned()
+{ 
+  return (subpart_type == NOT_A_PARTITION ?  FALSE : TRUE); 
+}
+
+
+/*
+  Returns the total number of partitions on the leaf level.
+  SYNOPSIS
+    get_tot_partitions()
+    part_info          A reference to the partition_info struct
+  RETURN VALUE
+    Returns the number of partitions
+  DESCRIPTION
+    A routine to check for number of partitions for improved readability
+    of code
+*/
+inline
+uint partition_info::get_tot_partitions()
+{
+  return no_parts * (is_sub_partitioned() ? no_subparts : 1);
+}
+
+uint32 get_next_partition_id_range(struct st_partition_iter* part_iter);
+
+/* Initialize the iterator to return a single partition with given part_id */
+
+static inline void init_single_partition_iterator(uint32 part_id,
+                                           PARTITION_ITERATOR *part_iter)
+{
+  part_iter->part_nums.start= part_id;
+  part_iter->part_nums.end= part_id+1;
+  part_iter->get_next= get_next_partition_id_range;
+}
+
+/* Initialize the iterator to enumerate all partitions */
+static inline
+void init_all_partitions_iterator(partition_info *part_info,
+                                  PARTITION_ITERATOR *part_iter)
+{
+  part_iter->part_nums.start= 0;
+  part_iter->part_nums.end= part_info->no_parts;
+  part_iter->get_next= get_next_partition_id_range;
+}