Increased heap max length to > 4G for 64 bit machines

Initialize key_part->type on open. This caused key_copy() to fail for bit_fields. (key_copy is used in HANDLER and opt_range)


include/heap.h:
  Increased heap max length to > 4G for 64 bit machines
mysql-test/r/show_check.result:
  Updated results after heap size change
mysql-test/r/type_bit.result:
  Added test for bug in bit field handling (in handler and opt_range.cc)
mysql-test/t/type_bit.test:
  Added test for bug in bit field handling (in handler and opt_range.cc)
sql/ha_heap.cc:
  Increased heap max length to > 4G for 64 bit machines
sql/item_sum.cc:
  Increased heap max length to > 4G for 64 bit machines
sql/mysqld.cc:
  Increased heap max length to > 4G for 64 bit machines
sql/set_var.cc:
  Increased heap max length to > 4G for 64 bit machines
sql/sql_class.h:
  Increased heap max length to > 4G for 64 bit machines
sql/sql_select.cc:
  Increased heap max length to > 4G for 64 bit machines
sql/table.cc:
  Initialize key_part->type ; This was used for bit fields but only set in temporary tables
sql/uniques.cc:
  Increased heap max length to > 4G for 64 bit machines

8 files changed, 29 insertions, 20 deletions

diff --git a/sql/ha_heap.cc b/sql/ha_heap.cc
index 34ef888a029..3cf7593bd8a 100644
--- a/sql/ha_heap.cc
+++ b/sql/ha_heap.cc
@@ -631,7 +631,7 @@ int ha_heap::create(const char *name, TABLE *table_arg,
   }
   mem_per_row+= MY_ALIGN(share->reclength + 1, sizeof(char*));
   max_rows = (ha_rows) (table->in_use->variables.max_heap_table_size /
-			mem_per_row);
+			(ulonglong) mem_per_row);
   if (table_arg->found_next_number_field)
   {
     keydef[share->next_number_index].flag|= HA_AUTO_KEY;
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index f1e0001c994..de0f713f454 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -3388,8 +3388,8 @@ bool Item_func_group_concat::setup(THD *thd)
       duplicate values (according to the syntax of this function). If there
       is no DISTINCT or ORDER BY clauses, we don't create this tree.
     */
-    init_tree(tree, min(thd->variables.max_heap_table_size,
-                        thd->variables.sortbuff_size/16), 0,
+    init_tree(tree, (uint) min(thd->variables.max_heap_table_size,
+                               thd->variables.sortbuff_size/16), 0,
               tree_key_length, compare_key, 0, NULL, (void*) this);
   }
 
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 36a5605b507..dd483b0b158 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -70,6 +70,12 @@
 #define IF_PURIFY(A,B) (B)
 #endif
 
+#if SIZEOF_CHARP == 4
+#define MAX_MEM_TABLE_SIZE ~(ulong) 0
+#else
+#define MAX_MEM_TABLE_SIZE ~(ulonglong) 0
+#endif
+
 /* stack traces are only supported on linux intel */
 #if defined(__linux__)  && defined(__i386__) && defined(USE_PSTACK)
 #define	HAVE_STACK_TRACE_ON_SEGV
@@ -5718,8 +5724,9 @@ The minimum value for this variable is 4096.",
   {"max_heap_table_size", OPT_MAX_HEP_TABLE_SIZE,
    "Don't allow creation of heap tables bigger than this.",
    (gptr*) &global_system_variables.max_heap_table_size,
-   (gptr*) &max_system_variables.max_heap_table_size, 0, GET_ULONG,
-   REQUIRED_ARG, 16*1024*1024L, 16384, ~0L, MALLOC_OVERHEAD, 1024, 0},
+   (gptr*) &max_system_variables.max_heap_table_size, 0, GET_ULL,
+   REQUIRED_ARG, 16*1024*1024L, 16384, MAX_MEM_TABLE_SIZE,
+   MALLOC_OVERHEAD, 1024, 0},
   {"max_join_size", OPT_MAX_JOIN_SIZE,
    "Joins that are probably going to read more than max_join_size records return an error.",
    (gptr*) &global_system_variables.max_join_size,
@@ -5994,8 +6001,8 @@ The minimum value for this variable is 4096.",
   {"tmp_table_size", OPT_TMP_TABLE_SIZE,
    "If an in-memory temporary table exceeds this size, MySQL will automatically convert it to an on-disk MyISAM table.",
    (gptr*) &global_system_variables.tmp_table_size,
-   (gptr*) &max_system_variables.tmp_table_size, 0, GET_ULONG,
-   REQUIRED_ARG, 32*1024*1024L, 1024, ~0L, 0, 1, 0},
+   (gptr*) &max_system_variables.tmp_table_size, 0, GET_ULL,
+   REQUIRED_ARG, 32*1024*1024L, 1024, MAX_MEM_TABLE_SIZE, 0, 1, 0},
   {"transaction_alloc_block_size", OPT_TRANS_ALLOC_BLOCK_SIZE,
    "Allocation block size for transactions to be stored in binary log",
    (gptr*) &global_system_variables.trans_alloc_block_size,
diff --git a/sql/set_var.cc b/sql/set_var.cc
index 55c62a9a5a5..c3e93aae619 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -248,7 +248,7 @@ sys_var_thd_ulong	sys_max_delayed_threads("max_delayed_threads",
                                                 fix_max_connections);
 sys_var_thd_ulong	sys_max_error_count("max_error_count",
 					    &SV::max_error_count);
-sys_var_thd_ulong	sys_max_heap_table_size("max_heap_table_size",
+sys_var_thd_ulonglong	sys_max_heap_table_size("max_heap_table_size",
 						&SV::max_heap_table_size);
 sys_var_thd_ulong       sys_pseudo_thread_id("pseudo_thread_id",
 					     &SV::pseudo_thread_id,
@@ -415,7 +415,7 @@ sys_var_thd_enum	sys_tx_isolation("tx_isolation",
 					 &SV::tx_isolation,
 					 &tx_isolation_typelib,
 					 fix_tx_isolation);
-sys_var_thd_ulong	sys_tmp_table_size("tmp_table_size",
+sys_var_thd_ulonglong	sys_tmp_table_size("tmp_table_size",
 					   &SV::tmp_table_size);
 sys_var_bool_ptr  sys_timed_mutexes("timed_mutexes",
                                     &timed_mutexes);
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 2467385b679..e3ae682edae 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -495,6 +495,8 @@ struct system_variables
 {
   ulonglong myisam_max_extra_sort_file_size;
   ulonglong myisam_max_sort_file_size;
+  ulonglong max_heap_table_size;
+  ulonglong tmp_table_size;
   ha_rows select_limit;
   ha_rows max_join_size;
   ulong auto_increment_increment, auto_increment_offset;
@@ -503,7 +505,6 @@ struct system_variables
   ulong long_query_time;
   ulong max_allowed_packet;
   ulong max_error_count;
-  ulong max_heap_table_size;
   ulong max_length_for_sort_data;
   ulong max_sort_length;
   ulong max_tmp_tables;
@@ -527,7 +528,6 @@ struct system_variables
   ulong div_precincrement;
   ulong sortbuff_size;
   ulong table_type;
-  ulong tmp_table_size;
   ulong tx_isolation;
   ulong completion_type;
   /* Determines which non-standard SQL behaviour should be enabled */
@@ -2068,7 +2068,8 @@ class user_var_entry
 class Unique :public Sql_alloc
 {
   DYNAMIC_ARRAY file_ptrs;
-  ulong max_elements, max_in_memory_size;
+  ulong max_elements;
+  ulonglong max_in_memory_size;
   IO_CACHE file;
   TREE tree;
   byte *record_pointers;
@@ -2078,7 +2079,7 @@ class Unique :public Sql_alloc
 public:
   ulong elements;
   Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
-	 uint size_arg, ulong max_in_memory_size_arg);
+	 uint size_arg, ulonglong max_in_memory_size_arg);
   ~Unique();
   ulong elements_in_tree() { return tree.elements_in_tree; }
   inline bool unique_add(void *ptr)
@@ -2092,13 +2093,13 @@ public:
 
   bool get(TABLE *table);
   static double get_use_cost(uint *buffer, uint nkeys, uint key_size,
-                             ulong max_in_memory_size);
+                             ulonglong max_in_memory_size);
   inline static int get_cost_calc_buff_size(ulong nkeys, uint key_size,
-                                            ulong max_in_memory_size)
+                                            ulonglong max_in_memory_size)
   {
-    register ulong max_elems_in_tree=
+    register ulonglong max_elems_in_tree=
       (1 + max_in_memory_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
-    return sizeof(uint)*(1 + nkeys/max_elems_in_tree);
+    return (int) (sizeof(uint)*(1 + nkeys/max_elems_in_tree));
   }
 
   void reset();
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 1d89cac584a..4758371f2e0 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -9254,7 +9254,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
   param->recinfo=recinfo;
   store_record(table,s->default_values);        // Make empty default record
 
-  if (thd->variables.tmp_table_size == ~(ulong) 0)		// No limit
+  if (thd->variables.tmp_table_size == ~ (ulonglong) 0)		// No limit
     table->s->max_rows= ~(ha_rows) 0;
   else
     table->s->max_rows= (((table->s->db_type == DB_TYPE_HEAP) ?
diff --git a/sql/table.cc b/sql/table.cc
index 5a2281775b1..eed90eb411f 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -730,6 +730,7 @@ int openfrm(THD *thd, const char *name, const char *alias, uint db_stat,
 	if (key_part->fieldnr)
 	{					// Should always be true !
 	  Field *field=key_part->field=outparam->field[key_part->fieldnr-1];
+          key_part->type= field->key_type();
 	  if (field->null_ptr)
 	  {
 	    key_part->null_offset=(uint) ((byte*) field->null_ptr -
diff --git a/sql/uniques.cc b/sql/uniques.cc
index ad074f8b2b0..ac603791376 100644
--- a/sql/uniques.cc
+++ b/sql/uniques.cc
@@ -55,7 +55,7 @@ int unique_write_to_ptrs(gptr key, element_count count, Unique *unique)
 }
 
 Unique::Unique(qsort_cmp2 comp_func, void * comp_func_fixed_arg,
-	       uint size_arg, ulong max_in_memory_size_arg)
+	       uint size_arg, ulonglong max_in_memory_size_arg)
   :max_in_memory_size(max_in_memory_size_arg), size(size_arg), elements(0)
 {
   my_b_clear(&file);
@@ -260,7 +260,7 @@ static double get_merge_many_buffs_cost(uint *buffer,
 */
 
 double Unique::get_use_cost(uint *buffer, uint nkeys, uint key_size,
-                            ulong max_in_memory_size)
+                            ulonglong max_in_memory_size)
 {
   ulong max_elements_in_tree;
   ulong last_tree_elems;