Merge lp:~ivolucien/drizzle/trunk-bug-621861 into lp:~drizzle-trunk/drizzle/development

[Mark Atwood]

[Olaf van der Spek (olafvdspek)]

+ void* getCustomArg() {

Hi Mark,

I think indentation is too much and the brace should be on the next line.

Greetings,

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2011-12-24 17:41:25 +0000
@@ -0,0 +1,386 @@
+*.bb
+*.bbg
+*.da
+*.dirstamp
+*.gcda
+*.gcno
+*.gmo
+*.gz
+*.la
+*.linted
+*.lo
+*.orig
+*.rej
+*.reject
+*.rpm
+*replication.pb.*
+*stamp-h
+./ChangeLog
+.DS_Store
+.deps
+.libs
+.plugin.ini.stamp
+.plugin.scan
+ChangeLog
+DEPENDENCIES
+INSTALL
+Makefile
+Makefile.in
+TAGS
+aclocal.m4
+authentication.gcno
+autom4te.cache/
+cached_item.gcno
+calendar.gcno
+check_stack_overrun.gcno
+client/Makefile.in
+client/drizzle
+client/drizzleadmin
+client/drizzlebinlog
+client/drizzlecheck
+client/drizzledump
+client/drizzleimport
+client/drizzleslap
+client/drizzletest
+client/mysqlslap
+comp_creator.gcno
+compile
+config.guess
+config.h
+config.h.gch
+config.h.in
+config.log
+config.status
+config.sub
+config/bzr_revinfo
+config/pandora-plugin.list
+config/pandora_vc_revinfo
+config/plugin-list.ac
+config/plugin-list.am
+config/plugin.ac
+config/plugin.am
+config/plugin.list
+config/plugin.stamp
+config/top.h
+configure
+configvar.gcno
+current_session.gcno
+dbug/Makefile.in
+depcomp
+docs
+docs/doctrees
+docs/html
+docs/plugins/*
+docs/plugins/list.rst
+doxerr.log
+drizzle-2010.01.1315.tar.gz
+drizzle.pot
+drizzled.gcno
+drizzled/configmake.h
+drizzled/drizzled
+drizzled/drizzled_safe
+drizzled/function_hash.h
+drizzled/gen_lex_hash
+drizzled/generated_probes.h
+drizzled/lex_hash.h
+drizzled/message/alter_table.pb.cc
+drizzled/message/alter_table.pb.h
+drizzled/message/binary_log.pb.cc
+drizzled/message/binary_log.pb.h
+drizzled/message/binlog_reader
+drizzled/message/binlog_writer
+drizzled/message/command_reader
+drizzled/message/engine.pb.cc
+drizzled/message/engine.pb.h
+drizzled/message/event.pb.cc
+drizzled/message/event.pb.h
+drizzled/message/length
+drizzled/message/replication.pb.cc
+drizzled/message/replication.pb.h
+drizzled/message/replication_event.pb.cc
+drizzled/message/replication_event.pb.h
+drizzled/message/replication_event_reader
+drizzled/message/replication_event_writer
+drizzled/message/resultset.pb.cc
+drizzled/message/resultset.pb.h
+drizzled/message/schema.pb.cc
+drizzled/message/schema.pb.h
+drizzled/message/schema_reader
+drizzled/message/schema_writer
+drizzled/message/table.pb.cc
+drizzled/message/table.pb.h
+drizzled/message/table_raw_reader
+drizzled/message/table_reader
+drizzled/message/table_writer
+drizzled/message/transaction.pb.cc
+drizzled/message/transaction.pb.h
+drizzled/message/transaction_writer
+drizzled/module/load_list.h
+drizzled/plugin/version.h
+drizzled/schema.pb.cc
+drizzled/schema.pb.h
+drizzled/sql_builtin.cc
+drizzled/sql_yacc.cc
+drizzled/sql_yacc.h
+drizzled/sql_yacc.output
+drizzled/sql_reserved_words.h
+drizzled/symbol_hash.h
+drizzled/version.h
+dtcollation.gcno
+errmsg.gcno
+errmsg_print.gcno
+error.gcno
+examples/client
+examples/pipe_query
+examples/proxy
+examples/server
+examples/simple
+examples/simple_multi
+examples/sqlite_server
+extra/Makefile.in
+extra/comp_err
+extra/innochecksum
+extra/my_print_defaults
+extra/mysql_waitpid
+field.gcno
+field_conv.gcno
+field_iterator.gcno
+filesort.gcno
+gnulib/getopt.h
+gnulib/time.h
+gnulib/unistd.h
+ha_trx_info.gcno
+handler.gcno
+handlerton.gcno
+hybrid_type_traits.gcno
+hybrid_type_traits_decimal.gcno
+hybrid_type_traits_integer.gcno
+include/Makefile.in
+include/config.h
+include/drizzle_version.h
+include/mysqld_ername.h
+include/mysqld_error.h
+include/sql_state.h
+include/stamp-h1
+install-sh
+item.gcno
+key.gcno
+key_map.gcno
+libdrizzle-2.0/libdrizzle/mysql_password_hash
+libdrizzle-2.0/libdrizzle/drizzle_password_hash
+libmysql/Makefile.in
+libserialutil_la-db.gcno
+libserialutil_la-unireg.gcno
+libtool
+lint-rules.am
+lock.gcno
+log.gcno
+logging.gcno
+ltmain.sh
+m4/bzr_version.m4
+m4/libtool.m4
+m4/ltoptions.m4
+m4/ltsugar.m4
+m4/ltversion.m4
+m4/lt~obsolete.m4
+mf_iocache.gcno
+missing
+my_decimal.gcno
+mysql-test/Makefile.in
+mysys/Makefile.in
+mysys/tests/Makefile.in
+name_resolution_context_state.gcno
+natural_join_column.gcno
+opt_range.gcno
+opt_sum.gcno
+out
+pandora-plugin.ac
+pandora-plugin.am
+parser.gcno
+patch
+plugin/Makefile.in
+plugin/archive/Makefile.in
+plugin/archive/archive_performance
+plugin/archive/archive_reader
+plugin/archive/archive_test
+plugin/archive/concurrency_test
+plugin/blackhole/Makefile.in
+plugin/csv/Makefile.in
+plugin/heap/Makefile.in
+plugin/innobase/Makefile.in
+plugin/innobase/include/pars0grm.hh
+plugin/innobase/include/pars0grm.h
+plugin/innobase/pars/pars0grm.c
+plugin/innobase/pars/pars0grm.cc
+plugin/innobase/pars/pars0grm.h
+plugin/innobase/pars/pars0lex.c
+plugin/memcached_functions/start_mc.sh
+plugin/memcached_functions/tests/start_mc.sh
+plugin/myisam/Makefile.in
+plugin/myisam/myisamchk
+plugin/myisam/myisamlog
+plugin/myisam/myisampack
+plugin/storage_engine_api_tester/cursor_states_to_dot
+plugin/storage_engine_api_tester/engine_states_to_dot
+plugin/transaction_log/utilities/drizzletrx
+po/POTFILES
+po/drizzle7.pot
+po/remove-potcdate.sed
+po/stamp-it
+po/stamp-po
+protocol.gcno
+qcache.gcno
+query_id.gcno
+records.gcno
+regex/Makefile.in
+rename.gcno
+replicator.gcno
+scheduling.gcno
+scripts/Makefile.in
+server/drizzled_safe
+server/gen_lex_hash
+server/lex_hash.h
+server/share/czech/
+server/share/danish/
+server/share/dutch/
+server/share/english/
+server/share/estonian/
+server/share/french/
+server/share/german/
+server/share/greek/
+server/share/hungarian/
+server/share/italian/
+server/share/japanese-sjis/
+server/share/japanese/
+server/share/korean/
+server/share/norwegian-ny/
+server/share/norwegian/
+server/share/polish/
+server/share/portuguese/
+server/share/romanian/
+server/share/russian/
+server/share/serbian/
+server/share/slovak/
+server/share/spanish/
+server/share/swedish/
+server/share/ukrainian/
+server/sql_yacc.cc
+server/sql_yacc.h
+server/sql_yacc.output
+session.gcno
+set_var.gcno
+show.gcno
+sj_tmp_table.gcno
+sql-common/Makefile.in
+sql/Makefile.in
+sql/share/Makefile.in
+sql_base.gcno
+sql_client.gcno
+sql_connect.gcno
+sql_delete.gcno
+sql_derived.gcno
+sql_error.gcno
+sql_handler.gcno
+sql_insert.gcno
+sql_lex.gcno
+sql_list.gcno
+sql_load.gcno
+sql_locale.gcno
+sql_parse.gcno
+sql_plugin.gcno
+sql_select.gcno
+sql_state.gcno
+sql_string.gcno
+sql_table.gcno
+sql_udf.gcno
+sql_union.gcno
+sql_update.gcno
+sql_yacc.gcno
+stacktrace.gcno
+stamp-h1
+strfunc.gcno
+strings/Makefile.in
+strings/tests/Makefile.in
+support-files/Makefile.in
+support-files/drizzle-log-rotate
+support-files/drizzle7.pc
+support-files/drizzle.server
+support-files/drizzle.spec
+support-files/libdrizzle.pc
+support-files/libdrizzle-1.0.pc
+support-files/libdrizzle-2.0.pc
+support-files/libdrizzleclient.pc
+support-files/smf/Makefile.in
+support-files/smf/drizzle
+support-files/smf/drizzle.xml
+support-files/smf/install.sh
+table.gcno
+table_map_iterator.gcno
+temporal.gcno
+temporal_format.gcno
+tests/Makefile.in
+tests/dtr
+tests/dtr@
+tests/dbqp
+tests/dbqp_data/uuid
+tests/dbqp_work
+tests/install_test_db
+tests/mtr
+tests/mtr@
+tests/resolve_stack_dump
+tests/stripped_log
+tests/test-run
+tests/test-run@
+tests/total_warning_count
+tests/var
+tests/workdir
+thr_malloc.gcno
+time.gcno
+tmp_table.gcno
+tztime.gcno
+uniques.gcno
+unittests/atomics_test
+unittests/calendar_test
+unittests/unittests
+unittests/uwagi.txt
+virtual_column_info.gcno
+xid.gcno
+ylwrap
+docs/html
+docs/dirhtml
+docs/singlehtml
+docs/pickle
+docs/json
+docs/htmlhelp
+docs/qthelp
+docs/devhelp
+docs/epub
+docs/latex
+docs/latexpdf
+docs/text
+docs/man
+docs/changes
+docs/linkcheck
+docs/doctest
+.pc
+drizzled/message/catalog.pb.cc
+drizzled/message/catalog.pb.h
+drizzled/message/catalog_reader
+drizzled/message/catalog_writer
+drizzled/message/replication_options.pb.cc
+drizzled/message/replication_options.pb.h
+drizzled/message/access.pb.cc
+drizzled/message/access.pb.h
+drizzled/execute/parser.cc
+drizzled/execute/parser.h
+drizzled/execute/parser.output
+drizzled/execute/scanner.cc
+drizzled/execute/scanner.h
+plugin/innobase/xtrabackup/drizzlebackup.innobase
+libdrizzle-2.0/drizzle_password_hash
+libdrizzle-2.0/mysql_password_hash
+.autotools
+.cproject
+.metadata
+.project
+.settings
 
=== renamed file '.bzrignore' => '.bzrignore.THIS'
=== modified file 'drizzled/item/sum.cc'
--- drizzled/item/sum.cc	2011-10-19 09:25:53 +0000
+++ drizzled/item/sum.cc	2011-12-24 17:41:25 +0000
@@ -3048,7 +3048,7 @@
       table= 0;
       if (tree)
       {
-        delete_tree(tree);
+        tree->delete_tree();
         tree= 0;
       }
 
@@ -3083,7 +3083,7 @@
   warning_for_row= false;
   no_appended= true;
   if (tree)
-    reset_tree(tree);
+    tree->reset_tree();
   if (distinct)
     unique_filter->reset();
   /* No need to reset the table as we never call write_row */
@@ -3121,10 +3121,10 @@
       row_eligible= false;
   }
 
-  TREE_ELEMENT *el= 0;                          // Only for safety
+  Tree_Element *el= 0;                          // Only for safety
   if (row_eligible && tree)
-    el= tree_insert(tree, table->record[0] + table->getShare()->null_bytes, 0,
-                    tree->custom_arg);
+    el= tree->tree_insert(table->record[0] + table->getShare()->null_bytes, 0,
+                    tree->getCustomArg());
   /*
     If the row is not a duplicate (el->count == 1)
     we can dump the row here in case of GROUP_CONCAT(DISTINCT...)
@@ -3273,7 +3273,7 @@
       syntax of this function). If there is no ORDER BY clause, we don't
       create this tree.
     */
-    init_tree(tree, (uint32_t) min(session->variables.max_heap_table_size,
+     tree->init_tree((uint32_t) min(session->variables.max_heap_table_size,
                                    (uint64_t)(session->variables.sortbuff_size/16)), 
               0,
               tree_key_length,
@@ -3325,8 +3325,7 @@
     return 0;
   if (no_appended && tree)
     /* Tree is used for sorting as in ORDER BY */
-    tree_walk(tree, (tree_walk_action)&dump_leaf_key, (void*)this,
-              left_root_right);
+    tree->tree_walk((tree_walk_action)&dump_leaf_key, (void*)this, left_root_right);
   if (count_cut_values && !warning)
   {
     /*
 
=== modified file 'drizzled/item/sum.h'
--- drizzled/item/sum.h	2011-04-20 22:18:30 +0000
+++ drizzled/item/sum.h	2011-12-24 17:41:25 +0000
@@ -950,8 +950,8 @@
   DRIZZLE_ERROR *warning;
   String result;
   String *separator;
-  TREE tree_base;
-  TREE *tree;
+  Tree tree_base;
+  Tree *tree;
 
   /**
      If DISTINCT is used with this GROUP_CONCAT, this member is used to filter
 
=== modified file 'drizzled/tree.cc'
--- drizzled/tree.cc	2011-06-22 14:19:44 +0000
+++ drizzled/tree.cc	2011-12-24 17:41:25 +0000
@@ -15,7 +15,7 @@
 
 /*
   Code for handling red-black (balanced) binary trees.
-  key in tree is allocated accrding to following:
+  key in tree is allocated according to following:
 
   1) If size < 0 then tree will not allocate keys and only a pointer to
      each key is saved in tree.
@@ -29,8 +29,8 @@
   3) if key_size is given to init_tree then each node will continue the
      key and calls to insert_key may increase length of key.
      if key_size > sizeof(pointer) and key_size is a multiple of 8 (double
-     allign) then key will be put on a 8 alligned adress. Else
-     the key will be on adress (element+1). This is transparent for user
+     align) then key will be put on a 8 aligned address. Else
+     the key will be on address (element+1). This is transparent for user
      compare and search functions uses a pointer to given key-argument.
 
   - If you use a free function for tree-elements and you are freeing
@@ -48,9 +48,9 @@
 /*
   NOTE:
   tree->compare function should be ALWAYS called as
-    (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element), key)
-  and not other way around, as
-    (*tree->compare)(custom_arg, key, ELEMENT_KEY(tree,element))
+    (*compare)(custom_arg, element_key(element), key)
+  and NOT the other way around, as
+    (*compare)(custom_arg, key, element_key(element))
 */
 
 #include <config.h>
@@ -58,150 +58,88 @@
 #include <drizzled/tree.h>
 #include <drizzled/internal/my_sys.h>
 #include <drizzled/internal/m_string.h>
-#include <drizzled/memory/root.h>
 
 #define BLACK		1
 #define RED		0
 #define DEFAULT_ALLOC_SIZE 8192
 #define DEFAULT_ALIGN_SIZE 8192
 
-#define ELEMENT_KEY(tree,element)\
-(tree->offset_to_key ? (void*)((unsigned char*) element+tree->offset_to_key) :\
-			*((void**) (element+1)))
-#define ELEMENT_CHILD(element, offs) (*(TREE_ELEMENT**)((char*)element + offs))
 
 namespace drizzled
 {
 
-
-static void delete_tree_element(TREE *,TREE_ELEMENT *);
-static int tree_walk_left_root_right(TREE *,TREE_ELEMENT *,
-				     tree_walk_action,void *);
-static int tree_walk_right_root_left(TREE *,TREE_ELEMENT *,
-				     tree_walk_action,void *);
-static void left_rotate(TREE_ELEMENT **parent,TREE_ELEMENT *leaf);
-static void right_rotate(TREE_ELEMENT **parent, TREE_ELEMENT *leaf);
-static void rb_insert(TREE *tree,TREE_ELEMENT ***parent,
-		      TREE_ELEMENT *leaf);
-
-
-void init_tree(TREE *tree, size_t default_alloc_size, uint32_t memory_limit,
-               uint32_t size, qsort_cmp2 compare, bool with_delete,
-	       tree_element_free free_element, void *custom_arg)
+/**
+ * Tree class public methods
+ */
+
+void Tree::init_tree(size_t default_alloc_size, uint32_t mem_limit,
+               uint32_t size, qsort_cmp2 compare_callback, bool free_with_tree,
+	       tree_element_free free_callback, void *caller_arg)
 {
   if (default_alloc_size < DEFAULT_ALLOC_SIZE)
     default_alloc_size= DEFAULT_ALLOC_SIZE;
   default_alloc_size= MY_ALIGN(default_alloc_size, DEFAULT_ALIGN_SIZE);
-  memset(&tree->null_element, 0, sizeof(tree->null_element));
-  tree->root= &tree->null_element;
-  tree->compare= compare;
-  tree->size_of_element= size > 0 ? (uint32_t) size : 0;
-  tree->memory_limit= memory_limit;
-  tree->free= free_element;
-  tree->allocated= 0;
-  tree->elements_in_tree= 0;
-  tree->custom_arg = custom_arg;
-  tree->null_element.colour= BLACK;
-  tree->null_element.left=tree->null_element.right= 0;
-  tree->flag= 0;
-  if (!free_element &&
+  memset(&this->null_element, 0, sizeof(this->null_element));
+  root= &this->null_element;
+  compare= compare_callback;
+  size_of_element= size > 0 ? (uint32_t) size : 0;
+  memory_limit= mem_limit;
+  free= free_callback;
+  allocated= 0;
+  elements_in_tree= 0;
+  custom_arg = caller_arg;
+  null_element.colour= BLACK;
+  null_element.left=this->null_element.right= 0;
+  flag= 0;
+  if (!free_callback &&
       (size <= sizeof(void*) || ((uint32_t) size & (sizeof(void*)-1))))
   {
     /*
       We know that the data doesn't have to be aligned (like if the key
       contains a double), so we can store the data combined with the
-      TREE_ELEMENT.
+      Tree_Element.
     */
-    tree->offset_to_key= sizeof(TREE_ELEMENT); /* Put key after element */
+    offset_to_key= sizeof(Tree_Element); /* Put key after element */
     /* Fix allocation size so that we don't lose any memory */
-    default_alloc_size/= (sizeof(TREE_ELEMENT)+size);
+    default_alloc_size/= (sizeof(Tree_Element)+size);
     if (!default_alloc_size)
       default_alloc_size= 1;
-    default_alloc_size*= (sizeof(TREE_ELEMENT)+size);
+    default_alloc_size*= (sizeof(Tree_Element)+size);
   }
   else
   {
-    tree->offset_to_key= 0;		/* use key through pointer */
-    tree->size_of_element+= sizeof(void*);
-  }
-  if (! (tree->with_delete= with_delete))
-  {
-    tree->mem_root.init(default_alloc_size);
-    tree->mem_root.min_malloc= (sizeof(TREE_ELEMENT)+tree->size_of_element);
-  }
-}
-
-static void free_tree(TREE *tree, myf free_flags)
-{
-  if (tree->root)				/* If initialized */
-  {
-    if (tree->with_delete)
-      delete_tree_element(tree,tree->root);
-    else
-    {
-      if (tree->free)
-      {
-        if (tree->memory_limit)
-          (*tree->free)(NULL, free_init, tree->custom_arg);
-	delete_tree_element(tree,tree->root);
-        if (tree->memory_limit)
-          (*tree->free)(NULL, free_end, tree->custom_arg);
-      }
-      tree->mem_root.free_root(free_flags);
-    }
-  }
-  tree->root= &tree->null_element;
-  tree->elements_in_tree= 0;
-  tree->allocated= 0;
-}
-
-void delete_tree(TREE* tree)
-{
-  free_tree(tree, MYF(0)); /* free() mem_root if applicable */
-}
-
-void reset_tree(TREE* tree)
+    offset_to_key= 0;		/* use key through pointer */
+    size_of_element+= sizeof(void*);
+  }
+  if (! (with_delete= free_with_tree))
+  {
+    mem_root.init(default_alloc_size);
+    mem_root.min_malloc= (sizeof(Tree_Element)+size_of_element);
+  }
+}
+
+void Tree::delete_tree()
+{
+  free_tree(MYF(0)); /* free() mem_root if applicable */
+}
+
+void Tree::reset_tree()
 {
   /* do not free mem_root, just mark blocks as free */
-  free_tree(tree, MYF(memory::MARK_BLOCKS_FREE));
-}
-
-
-static void delete_tree_element(TREE *tree, TREE_ELEMENT *element)
-{
-  if (element != &tree->null_element)
-  {
-    delete_tree_element(tree,element->left);
-    if (tree->free)
-      (*tree->free)(ELEMENT_KEY(tree,element), free_free, tree->custom_arg);
-    delete_tree_element(tree,element->right);
-    if (tree->with_delete)
-      free((char*) element);
-  }
-}
-
-
-/*
-  insert, search and delete of elements
-
-  The following should be true:
-    parent[0] = & parent[-1][0]->left ||
-    parent[0] = & parent[-1][0]->right
-*/
-
-TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint32_t key_size,
-                          void* custom_arg)
+  free_tree(MYF(memory::MARK_BLOCKS_FREE));
+}
+
+Tree_Element* Tree::tree_insert(void* key, uint32_t key_size, void* caller_arg)
 {
   int cmp;
-  TREE_ELEMENT *element,***parent;
+  Tree_Element *element,***parent;
 
-  parent= tree->parents;
-  *parent = &tree->root; element= tree->root;
+  parent= this->parents;
+  *parent = &this->root; element= this->root;
   for (;;)
   {
-    if (element == &tree->null_element ||
-	(cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element),
-                                key)) == 0)
+    if (element == &this->null_element ||
+	(cmp = (*compare)(caller_arg, element_key(element), key)) == 0)
       break;
     if (cmp < 0)
     {
@@ -212,26 +150,26 @@
       *++parent = &element->left; element= element->left;
     }
   }
-  if (element == &tree->null_element)
+  if (element == &this->null_element)
   {
-    size_t alloc_size= sizeof(TREE_ELEMENT)+key_size+tree->size_of_element;
-    tree->allocated+= alloc_size;
+    size_t alloc_size= sizeof(Tree_Element)+key_size+this->size_of_element;
+    this->allocated+= alloc_size;
 
-    if (tree->memory_limit && tree->elements_in_tree
-                           && tree->allocated > tree->memory_limit)
+    if (this->memory_limit && this->elements_in_tree
+                           && this->allocated > this->memory_limit)
     {
-      reset_tree(tree);
-      return tree_insert(tree, key, key_size, custom_arg);
+      reset_tree();
+      return tree_insert(key, key_size, caller_arg);
     }
 
-    key_size+= tree->size_of_element;
-    if (tree->with_delete)
-      element= (TREE_ELEMENT *) malloc(alloc_size);
+    key_size+= this->size_of_element;
+    if (this->with_delete)
+      element= (Tree_Element *) malloc(alloc_size);
     else
-      element= (TREE_ELEMENT *) tree->mem_root.alloc(alloc_size);
+      element= (Tree_Element *) this->mem_root.alloc(alloc_size);
     **parent= element;
-    element->left= element->right= &tree->null_element;
-    if (!tree->offset_to_key)
+    element->left= element->right= &this->null_element;
+    if (!this->offset_to_key)
     {
       if (key_size == sizeof(void*))		 /* no length, save pointer */
 	*((void**) (element+1))= key;
@@ -242,14 +180,14 @@
       }
     }
     else
-      memcpy((unsigned char*) element + tree->offset_to_key, key, key_size);
+      memcpy((unsigned char*) element + this->offset_to_key, key, key_size);
     element->count= 1;			/* May give warning in purify */
-    tree->elements_in_tree++;
-    rb_insert(tree,parent,element);	/* rebalance tree */
+    this->elements_in_tree++;
+    rb_insert(parent,element);	/* rebalance tree */
   }
   else
   {
-    if (tree->flag & TREE_NO_DUPS)
+    if (this->flag & TREE_NO_DUPS)
       return(NULL);
     element->count++;
     /* Avoid a wrap over of the count. */
@@ -260,238 +198,123 @@
   return element;
 }
 
-void *tree_search_key(TREE *tree, const void *key,
-                      TREE_ELEMENT **parents, TREE_ELEMENT ***last_pos,
-                      enum ha_rkey_function flag, void *custom_arg)
-{
-  TREE_ELEMENT *element= tree->root;
-  TREE_ELEMENT **last_left_step_parent= NULL, **last_right_step_parent= NULL;
-  TREE_ELEMENT **last_equal_element= NULL;
-
-/*
-  TODO: support for HA_READ_KEY_OR_PREV, HA_READ_PREFIX flags if needed.
-*/
-
-  *parents = &tree->null_element;
-  while (element != &tree->null_element)
-  {
-    int cmp;
-
-    *++parents= element;
-
-    if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element),
-			       key)) == 0)
-    {
-      switch (flag) {
-      case HA_READ_KEY_EXACT:
-      case HA_READ_KEY_OR_NEXT:
-      case HA_READ_BEFORE_KEY:
-	last_equal_element= parents;
-	cmp= 1;
-	break;
-      case HA_READ_AFTER_KEY:
-	cmp= -1;
-	break;
-      case HA_READ_PREFIX_LAST:
-      case HA_READ_PREFIX_LAST_OR_PREV:
-	last_equal_element= parents;
-	cmp= -1;
-	break;
-      default:
-	return NULL;
-      }
-    }
-    if (cmp < 0) /* element < key */
-    {
-      last_right_step_parent= parents;
-      element= element->right;
-    }
-    else
-    {
-      last_left_step_parent= parents;
-      element= element->left;
-    }
-  }
-  switch (flag) {
-  case HA_READ_KEY_EXACT:
-  case HA_READ_PREFIX_LAST:
-    *last_pos= last_equal_element;
-    break;
-  case HA_READ_KEY_OR_NEXT:
-    *last_pos= last_equal_element ? last_equal_element : last_left_step_parent;
-    break;
-  case HA_READ_AFTER_KEY:
-    *last_pos= last_left_step_parent;
-    break;
-  case HA_READ_PREFIX_LAST_OR_PREV:
-    *last_pos= last_equal_element ? last_equal_element : last_right_step_parent;
-    break;
-  case HA_READ_BEFORE_KEY:
-    *last_pos= last_right_step_parent;
-    break;
-  default:
-    return NULL;
-  }
-
-  return *last_pos ? ELEMENT_KEY(tree, **last_pos) : NULL;
-}
-
-void *tree_search_next(TREE *tree, TREE_ELEMENT ***last_pos, int l_offs,
-                       int r_offs)
-{
-  TREE_ELEMENT *x= **last_pos;
-
-  if (ELEMENT_CHILD(x, r_offs) != &tree->null_element)
-  {
-    x= ELEMENT_CHILD(x, r_offs);
-    *++*last_pos= x;
-    while (ELEMENT_CHILD(x, l_offs) != &tree->null_element)
-    {
-      x= ELEMENT_CHILD(x, l_offs);
-      *++*last_pos= x;
-    }
-    return ELEMENT_KEY(tree, x);
-  }
-  else
-  {
-    TREE_ELEMENT *y= *--*last_pos;
-    while (y != &tree->null_element && x == ELEMENT_CHILD(y, r_offs))
-    {
-      x= y;
-      y= *--*last_pos;
-    }
-    return y == &tree->null_element ? NULL : ELEMENT_KEY(tree, y);
-  }
-}
-
-/*
-  Expected that tree is fully balanced
-  (each path from root to leaf has the same length)
-*/
-ha_rows tree_record_pos(TREE *tree, const void *key,
-			enum ha_rkey_function flag, void *custom_arg)
-{
-  TREE_ELEMENT *element= tree->root;
-  double left= 1;
-  double right= tree->elements_in_tree;
-
-  while (element != &tree->null_element)
-  {
-    int cmp;
-
-    if ((cmp= (*tree->compare)(custom_arg, ELEMENT_KEY(tree, element),
-			       key)) == 0)
-    {
-      switch (flag) {
-      case HA_READ_KEY_EXACT:
-      case HA_READ_BEFORE_KEY:
-        cmp= 1;
-        break;
-      case HA_READ_AFTER_KEY:
-        cmp= -1;
-        break;
-      default:
-        return HA_POS_ERROR;
-      }
-    }
-    if (cmp < 0) /* element < key */
-    {
-      element= element->right;
-      left= (left + right) / 2;
-    }
-    else
-    {
-      element= element->left;
-      right= (left + right) / 2;
-    }
-  }
-
-  switch (flag) {
-  case HA_READ_KEY_EXACT:
-  case HA_READ_BEFORE_KEY:
-    return (ha_rows) right;
-  case HA_READ_AFTER_KEY:
-    return (ha_rows) left;
-  default:
-    return HA_POS_ERROR;
-  }
-}
-
-int tree_walk(TREE *tree, tree_walk_action action, void *argument, TREE_WALK visit)
-{
-  switch (visit) {
-  case left_root_right:
-    return tree_walk_left_root_right(tree,tree->root,action,argument);
-  case right_root_left:
-    return tree_walk_right_root_left(tree,tree->root,action,argument);
+int Tree::tree_walk(tree_walk_action action, void *argument, TREE_WALK visit)
+{
+	  switch (visit) {
+	  case left_root_right:
+	    return tree_walk_left_root_right(root,action,argument);
+	  case right_root_left:
+	    return tree_walk_right_root_left(root,action,argument);
   }
 
   return 0;			/* Keep gcc happy */
 }
 
-static int tree_walk_left_root_right(TREE *tree, TREE_ELEMENT *element, tree_walk_action action, void *argument)
+/**
+ * Tree class private methods
+ */
+
+void Tree::free_tree(myf free_flags)
+{
+  if (root)				/* If initialized */
+  {
+    if (with_delete)
+      delete_tree_element(root);
+    else
+    {
+      if (free)
+      {
+        if (memory_limit)
+          (*free)(NULL, free_init, custom_arg);
+        delete_tree_element(root);
+        if (memory_limit)
+          (*free)(NULL, free_end, custom_arg);
+      }
+      mem_root.free_root(free_flags);
+    }
+  }
+  root= &null_element;
+  elements_in_tree= 0;
+  allocated= 0;
+}
+
+void* Tree::element_key(Tree_Element* element)
+{
+	return offset_to_key ? (void*)((unsigned char*) element + offset_to_key)
+						 : *((void**)(element + 1));
+}
+
+void Tree::delete_tree_element(Tree_Element *element)
+{
+  if (element != &null_element)
+  {
+    delete_tree_element(element->left);
+    if (free)
+      (*free)(element_key(element), free_free, custom_arg);
+    delete_tree_element(element->right);
+    if (with_delete)
+      delete element;
+  }
+}
+
+int Tree::tree_walk_left_root_right(Tree_Element *element, tree_walk_action action, void *argument)
 {
   int error;
   if (element->left)				/* Not null_element */
   {
-    if ((error=tree_walk_left_root_right(tree,element->left,action,
+    if ((error=tree_walk_left_root_right(element->left,action,
 					  argument)) == 0 &&
-	(error=(*action)(ELEMENT_KEY(tree,element),
-			  element->count,
-			  argument)) == 0)
-      error=tree_walk_left_root_right(tree,element->right,action,argument);
+	(error=(*action)(element_key(element), element->count, argument)) == 0)
+      error=tree_walk_left_root_right(element->right,action,argument);
     return error;
   }
 
   return 0;
 }
 
-static int tree_walk_right_root_left(TREE *tree, TREE_ELEMENT *element, tree_walk_action action, void *argument)
+int Tree::tree_walk_right_root_left(Tree_Element *element, tree_walk_action action, void *argument)
 {
   int error;
   if (element->right)				/* Not null_element */
   {
-    if ((error=tree_walk_right_root_left(tree,element->right,action,
+    if ((error=tree_walk_right_root_left(element->right,action,
 					  argument)) == 0 &&
-	(error=(*action)(ELEMENT_KEY(tree,element),
+	(error=(*action)(element_key(element),
 			  element->count,
 			  argument)) == 0)
-     error=tree_walk_right_root_left(tree,element->left,action,argument);
+     error=tree_walk_right_root_left(element->left,action,argument);
     return error;
   }
 
   return 0;
 }
 
-
-/* Functions to fix up the tree after insert and delete */
-
-static void left_rotate(TREE_ELEMENT **parent, TREE_ELEMENT *leaf)
+void Tree::left_rotate(Tree_Element **parent, Tree_Element *element)
 {
-  TREE_ELEMENT *y;
+  Tree_Element *y;
 
-  y= leaf->right;
-  leaf->right= y->left;
+  y= element->right;
+  element->right= y->left;
   parent[0]= y;
-  y->left= leaf;
+  y->left= element;
 }
 
-static void right_rotate(TREE_ELEMENT **parent, TREE_ELEMENT *leaf)
+void Tree::right_rotate(Tree_Element **parent, Tree_Element *element)
 {
-  TREE_ELEMENT *x;
+	Tree_Element *x;
 
-  x= leaf->left;
-  leaf->left= x->right;
+  x= element->left;
+  element->left= x->right;
   parent[0]= x;
-  x->right= leaf;
+  x->right= element;
 }
 
-static void rb_insert(TREE *tree, TREE_ELEMENT ***parent, TREE_ELEMENT *leaf)
+void Tree::rb_insert(Tree_Element ***parent, Tree_Element *element)
 {
-  TREE_ELEMENT *y,*par,*par2;
+	Tree_Element *y,*par,*par2;
 
-  leaf->colour=RED;
-  while (leaf != tree->root && (par=parent[-1][0])->colour == RED)
+  element->colour=RED;
+  while (element != root && (par=parent[-1][0])->colour == RED)
   {
     if (par == (par2=parent[-2][0])->left)
     {
@@ -500,16 +323,16 @@
       {
 	par->colour= BLACK;
 	y->colour= BLACK;
-	leaf= par2;
+	element= par2;
 	parent-= 2;
-	leaf->colour= RED;		/* And the loop continues */
+	element->colour= RED;		/* And the loop continues */
       }
       else
       {
-	if (leaf == par->right)
+	if (element == par->right)
 	{
 	  left_rotate(parent[-1],par);
-	  par= leaf;			/* leaf is now parent to old leaf */
+	  par= element;			/* element is now parent to old element */
 	}
 	par->colour= BLACK;
 	par2->colour= RED;
@@ -524,16 +347,16 @@
       {
 	par->colour= BLACK;
 	y->colour= BLACK;
-	leaf= par2;
+	element= par2;
 	parent-= 2;
-	leaf->colour= RED;		/* And the loop continues */
+	element->colour= RED;		/* And the loop continues */
       }
       else
       {
-	if (leaf == par->left)
+	if (element == par->left)
 	{
 	  right_rotate(parent[-1],par);
-	  par= leaf;
+	  par= element;
 	}
 	par->colour= BLACK;
 	par2->colour= RED;
@@ -542,7 +365,7 @@
       }
     }
   }
-  tree->root->colour=BLACK;
+  root->colour=BLACK;
 }
 
 } /* namespace drizzled */
 
=== modified file 'drizzled/tree.h'
--- drizzled/tree.h	2011-03-14 05:40:28 +0000
+++ drizzled/tree.h	2011-12-24 17:41:25 +0000
@@ -17,14 +17,14 @@
 
 #include <unistd.h>
 
-#include <drizzled/base.h>		/* get 'enum ha_rkey_function' */
+#include <drizzled/base.h>		// for 'enum ha_rkey_function'
+#include <drizzled/memory/root.h>
 #include <drizzled/qsort_cmp.h>
-#include <drizzled/memory/root.h>
 
 namespace drizzled
 {
 
-/* Worst case tree is half full. This gives use 2^(MAX_TREE_HEIGHT/2) leafs */
+// Worst case tree is half full. This gives us 2^(MAX_TREE_HEIGHT/2) leaves
 static const int MAX_TREE_HEIGHT= 64;
 
 static const int TREE_NO_DUPS= 1;
@@ -35,56 +35,77 @@
 typedef enum { free_init, free_free, free_end } TREE_FREE;
 typedef void (*tree_element_free)(void*, TREE_FREE, void *);
 
-typedef struct st_tree_element {
-  struct st_tree_element *left,*right;
-  uint32_t count:31,
-	 colour:1;			/* black is marked as 1 */
-} TREE_ELEMENT;
-
-static const int TREE_ELEMENT_EXTRA_SIZE= (sizeof(TREE_ELEMENT) + sizeof(void*));
-
-
-typedef struct st_tree {
-  TREE_ELEMENT *root,null_element;
-  TREE_ELEMENT **parents[MAX_TREE_HEIGHT];
-  uint32_t offset_to_key, elements_in_tree, size_of_element;
-  size_t memory_limit;
-  size_t allocated;
-  qsort_cmp2 compare;
-  void *custom_arg;
-  memory::Root mem_root;
-  bool with_delete;
-  tree_element_free free;
-  uint32_t flag;
-} TREE;
-
-/* Functions on whole tree */
-void init_tree(TREE *tree, size_t default_alloc_size, uint32_t memory_limit,
-               uint32_t size, qsort_cmp2 compare, bool with_delete,
-	       tree_element_free free_element, void *custom_arg);
-void delete_tree(TREE*);
-void reset_tree(TREE*);
-
-/* 
-  similar to delete tree, except we do not free() blocks in mem_root
-*/
-#define is_tree_inited(tree) ((tree)->root != 0)
-
-/* Functions on leafs */
-TREE_ELEMENT *tree_insert(TREE *tree,void *key, uint32_t key_size,
-                          void *custom_arg);
-int tree_walk(TREE *tree,tree_walk_action action,
-	      void *argument, TREE_WALK visit);
-int tree_delete(TREE *tree, void *key, uint32_t key_size, void *custom_arg);
-void *tree_search_key(TREE *tree, const void *key,
-                      TREE_ELEMENT **parents, TREE_ELEMENT ***last_pos,
-                      enum ha_rkey_function flag, void *custom_arg);
-void *tree_search_edge(TREE *tree, TREE_ELEMENT **parents,
-                        TREE_ELEMENT ***last_pos, int child_offs);
-void *tree_search_next(TREE *tree, TREE_ELEMENT ***last_pos, int l_offs,
-                       int r_offs);
-ha_rows tree_record_pos(TREE *tree, const void *key,
-                        enum ha_rkey_function search_flag, void *custom_arg);
+
+class Tree_Element
+{
+public:
+	Tree_Element *left,*right;
+	uint32_t count:31,
+		 	 colour:1;			/* black is marked as 1 */
+};
+
+static const int TREE_ELEMENT_EXTRA_SIZE= (sizeof(Tree_Element) + sizeof(void*));
+
+/**
+ * red-black binary tree class
+ *
+ * NOTE: unused search code removed 11/2011
+ */
+class Tree
+{
+private:
+	Tree_Element *root, null_element;
+	void *custom_arg;
+	Tree_Element **parents[MAX_TREE_HEIGHT];
+	uint32_t offset_to_key, elements_in_tree, size_of_element;
+	size_t memory_limit;
+	size_t allocated;
+	qsort_cmp2 compare;
+	memory::Root mem_root;
+	bool with_delete;
+	tree_element_free free;
+	uint32_t flag;
+
+public:
+	void* getCustomArg() {
+		return custom_arg;
+	}
+	Tree_Element* getRoot() {
+		return root;
+	}
+	void setRoot(Tree_Element* root_arg) {
+		root = root_arg;
+	}
+	uint32_t getElementsInTree() {
+		return elements_in_tree;
+	}
+	// tree methods
+	void init_tree(size_t default_alloc_size, uint32_t memory_limit,
+				   uint32_t size, qsort_cmp2 compare, bool with_delete,
+				   tree_element_free free_element, void *custom_arg);
+	bool is_inited()
+	{
+		return this->root != 0;
+	}
+	void delete_tree();
+	void reset_tree();
+
+	// element methods
+	Tree_Element *tree_insert(void *key, uint32_t key_size, void *custom_arg);
+	int tree_walk(tree_walk_action action, void *argument, TREE_WALK visit);
+
+private:
+	void free_tree(myf free_flags);
+
+	void* element_key(Tree_Element* element);
+	void delete_tree_element(Tree_Element* element);
+	int tree_walk_left_root_right(Tree_Element* element, tree_walk_action action, void* argument);
+	int tree_walk_right_root_left(Tree_Element* element, tree_walk_action action, void* argument);
+
+	void left_rotate(Tree_Element **parent,Tree_Element *element);
+	void right_rotate(Tree_Element **parent, Tree_Element *element);
+	void rb_insert(Tree_Element ***parent, Tree_Element *element);
+};
 
 } /* namespace drizzled */
 
 
=== modified file 'drizzled/unique.cc'
--- drizzled/unique.cc	2011-03-19 17:01:16 +0000
+++ drizzled/unique.cc	2011-12-24 17:41:25 +0000
@@ -62,7 +62,7 @@
     elements(0)
 {
   // Second element is max size for memory use in unique sort
-  init_tree(&tree, 0, 0, size, comp_func, false,
+  tree.init_tree(0, 0, size, comp_func, false,
             NULL, comp_func_fixed_arg);
 }
 
@@ -146,7 +146,7 @@
   double result;
 
   max_elements_in_tree= ((ulong) max_in_memory_size_arg /
-                         ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
+                         ALIGN_SIZE(sizeof(Tree_Element)+key_size));
 
   last_tree_elems= nkeys % max_elements_in_tree;
 
@@ -159,7 +159,7 @@
 
 Unique::~Unique()
 {
-  delete_tree(&tree);
+   tree.delete_tree();
 }
 
 
@@ -171,7 +171,7 @@
 void
 Unique::reset()
 {
-  reset_tree(&tree);
+  tree.reset_tree();
   assert(elements == 0);
 }
 
@@ -198,7 +198,7 @@
 
 bool Unique::walk(tree_walk_action action, void *walk_action_arg)
 {
-  return tree_walk(&tree, action, walk_action_arg, left_root_right);
+  return tree.tree_walk(action, walk_action_arg, left_root_right);
 }
 
 /*
@@ -208,12 +208,12 @@
 
 bool Unique::get(Table *table)
 {
-  table->sort.found_records= elements+tree.elements_in_tree;
+  table->sort.found_records= elements+tree.getElementsInTree();
 
   if ((record_pointers=table->sort.record_pointers= (unsigned char*)
-       malloc(size * tree.elements_in_tree)))
+       malloc(size * tree.getElementsInTree())))
   {
-    (void) tree_walk(&tree, (tree_walk_action) unique_write_to_ptrs,
+    (void) tree.tree_walk((tree_walk_action) unique_write_to_ptrs,
                      this, left_root_right);
     return 0;
   }
 
=== modified file 'drizzled/unique.h'
--- drizzled/unique.h	2011-04-29 00:19:38 +0000
+++ drizzled/unique.h	2011-12-24 17:41:25 +0000
@@ -40,7 +40,7 @@
 class Unique : public memory::SqlAlloc
 {
   size_t max_in_memory_size;
-  TREE tree;
+  Tree tree;
   unsigned char *record_pointers;
   uint32_t size;
 
@@ -49,10 +49,10 @@
   Unique(qsort_cmp2 comp_func, void *comp_func_fixed_arg,
 	 uint32_t size_arg, size_t max_in_memory_size_arg);
   ~Unique();
-  ulong elements_in_tree() { return tree.elements_in_tree; }
+  ulong elements_in_tree() { return tree.getElementsInTree(); }
   inline bool unique_add(void *ptr)
   {
-    return (not tree_insert(&tree, ptr, 0, tree.custom_arg));
+    return (not tree.tree_insert(ptr, 0, tree.getCustomArg()));
   }
 
   bool get(Table *table);
@@ -62,7 +62,7 @@
                                             size_t sortbuff_size)
   {
     register size_t max_elems_in_tree=
-      (1 + sortbuff_size / ALIGN_SIZE(sizeof(TREE_ELEMENT)+key_size));
+      (1 + sortbuff_size / ALIGN_SIZE(sizeof(Tree_Element)+key_size));
     return (int) (sizeof(uint32_t)*(1 + nkeys/max_elems_in_tree));
   }
 
 
=== modified file 'plugin/myisam/mi_write.cc'
--- plugin/myisam/mi_write.cc	2011-02-17 00:14:13 +0000
+++ plugin/myisam/mi_write.cc	2011-12-24 17:41:25 +0000
@@ -19,6 +19,7 @@
 
 #include <drizzled/internal/m_string.h>
 #include <drizzled/util/test.h>
+#include <drizzled/tree.h>
 
 using namespace drizzled;
 
@@ -97,7 +98,7 @@
     {
       bool local_lock_tree= (lock_tree &&
                                 !(info->bulk_insert &&
-                                  is_tree_inited(&info->bulk_insert[i])));
+                                  info->bulk_insert[i].is_inited()));
       if (local_lock_tree)
       {
 	share->keyinfo[i].version++;
@@ -188,7 +189,7 @@
 
 int _mi_ck_write(MI_INFO *info, uint32_t keynr, unsigned char *key, uint32_t key_length)
 {
-  if (info->bulk_insert && is_tree_inited(&info->bulk_insert[keynr]))
+  if (info->bulk_insert && info->bulk_insert[keynr].is_inited())
   {
     return(_mi_ck_write_tree(info, keynr, key, key_length));
   }
@@ -716,9 +717,9 @@
 {
   int error;
 
-  error= tree_insert(&info->bulk_insert[keynr], key,
+  error= info->bulk_insert[keynr].tree_insert(key,
          key_length + info->s->rec_reflength,
-         info->bulk_insert[keynr].custom_arg) ? 0 : HA_ERR_OUT_OF_MEM ;
+         info->bulk_insert[keynr].getCustomArg()) ? 0 : HA_ERR_OUT_OF_MEM ;
 
   return(error);
 } /* _mi_ck_write_tree */
@@ -797,8 +798,7 @@
   else
     cache_size/=total_keylength*16;
 
-  info->bulk_insert=(TREE *)
-    malloc((sizeof(TREE)*share->base.keys+
+  info->bulk_insert=(Tree *) malloc((sizeof(Tree)*share->base.keys+
            sizeof(bulk_insert_param)*num_keys));
 
   if (!info->bulk_insert)
@@ -812,14 +812,13 @@
       params->info=info;
       params->keynr=i;
       /* Only allocate a 16'th of the buffer at a time */
-      init_tree(&info->bulk_insert[i],
-                cache_size * key[i].maxlength,
+      info->bulk_insert[i].init_tree(cache_size * key[i].maxlength,
                 cache_size * key[i].maxlength, 0,
 		(qsort_cmp2)keys_compare, false,
 		(tree_element_free) keys_free, (void *)params++);
     }
     else
-     info->bulk_insert[i].root=0;
+     info->bulk_insert[i].setRoot(0);
   }
 
   return(0);
@@ -829,8 +828,8 @@
 {
   if (info->bulk_insert)
   {
-    if (is_tree_inited(&info->bulk_insert[inx]))
-      reset_tree(&info->bulk_insert[inx]);
+    if (info->bulk_insert[inx].is_inited())
+      info->bulk_insert[inx].reset_tree();
   }
 }
 
@@ -841,9 +840,9 @@
     uint32_t i;
     for (i=0 ; i < info->s->base.keys ; i++)
     {
-      if (is_tree_inited(& info->bulk_insert[i]))
+      if (info->bulk_insert[i].is_inited())
       {
-        delete_tree(& info->bulk_insert[i]);
+        info->bulk_insert[i].delete_tree();
       }
     }
     free((void *)info->bulk_insert);
 
=== modified file 'plugin/myisam/myisam_priv.h'
--- plugin/myisam/myisam_priv.h	2011-08-22 13:44:06 +0000
+++ plugin/myisam/myisam_priv.h	2011-12-24 17:41:25 +0000
@@ -21,7 +21,8 @@
 
 #include "myisam.h"			/* Structs & some defines */
 #include "myisampack.h"			/* packing of keys */
-#include <drizzled/tree.h>
+#include <drizzled/memory/root.h>
+
 #include <drizzled/internal/my_pthread.h>
 #include <drizzled/thr_lock.h>
 #include <drizzled/common.h>
@@ -36,6 +37,10 @@
 
 #include <boost/thread/mutex.hpp>
 
+namespace drizzled {
+class Tree;
+}
+
 #if defined(my_write)
 #undef my_write				/* undef map from my_nosys; We need test-if-disk full */
 #endif
@@ -249,7 +254,7 @@
   MI_BLOB     *blobs;			/* Pointer to blobs */
   MI_BIT_BUFF  bit_buff;
   /* accumulate indexfile changes between write's */
-  drizzled::TREE	        *bulk_insert;
+  drizzled::Tree	*bulk_insert;
   drizzled::Session *in_use;                      /* Thread using this table          */
   char *filename;			/* parameter to open filename       */
   unsigned char *buff,				/* Temp area for key                */