Merge lp:~brianaker/drizzle/refactor into lp:~drizzle-trunk/drizzle/development

[Brian Aker]

[lp:~brianaker/drizzle/refactor]

1870. By Brian Aker on 2010-10-22

Merge Monty

1871. By Lee Bieber on 2010-10-22

Merge Barry - fix bug 657830: PBMS build failure in GCC 4.5

1872. By Brian Aker on 2010-10-22

Merge in Brian. key creation should be improved after this (ie for share)

1873. By Brian Aker on 2010-10-22

Merge in overhaul to how cursor and table are handled. Cursor now only knows
about table, and will always have a table and engine reference.

This cleans up a number of ownership issues, the biggest being that it now
creates the space needed for the next big refactor in locks.

=== modified file 'drizzled/cursor.cc'
--- drizzled/cursor.cc	2010-10-22 00:20:21 +0000
+++ drizzled/cursor.cc	2010-10-23 00:16:13 +0000
@@ -54,9 +54,10 @@
 ** General Cursor functions
 ****************************************************************************/
 Cursor::Cursor(plugin::StorageEngine &engine_arg,
-               TableShare &share_arg)
-  : table_share(&share_arg), table(0),
-    estimation_rows_to_insert(0), engine(&engine_arg),
+               Table &arg)
+  : table(arg),
+    engine(engine_arg),
+    estimation_rows_to_insert(0),
     ref(0),
     key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
     ref_length(sizeof(internal::my_off_t)),
@@ -79,7 +80,7 @@
  */
 Cursor *Cursor::clone(memory::Root *mem_root)
 {
-  Cursor *new_handler= table->getMutableShare()->db_type()->getCursor(*table->getMutableShare());
+  Cursor *new_handler= getTable()->getMutableShare()->db_type()->getCursor(*getTable());
 
   /*
     Allocate Cursor->ref here because otherwise ha_open will allocate it
@@ -89,13 +90,12 @@
   if (!(new_handler->ref= (unsigned char*) mem_root->alloc_root(ALIGN_SIZE(ref_length)*2)))
     return NULL;
 
-  TableIdentifier identifier(table->getShare()->getSchemaName(),
-                             table->getShare()->getTableName(),
-                             table->getShare()->getType());
+  TableIdentifier identifier(getTable()->getShare()->getSchemaName(),
+                             getTable()->getShare()->getTableName(),
+                             getTable()->getShare()->getType());
 
   if (new_handler && !new_handler->ha_open(identifier,
-                                           table,
-                                           table->getDBStat(),
+                                           getTable()->getDBStat(),
                                            HA_OPEN_IGNORE_IF_LOCKED))
     return new_handler;
   return NULL;
@@ -111,8 +111,8 @@
   /* works only with key prefixes */
   assert(((keypart_map_arg + 1) & keypart_map_arg) == 0);
 
-  const KeyPartInfo *key_part_found= table->getShare()->getKeyInfo(key_position).key_part;
-  const KeyPartInfo *end_key_part_found= key_part_found + table->getShare()->getKeyInfo(key_position).key_parts;
+  const KeyPartInfo *key_part_found= getTable()->getShare()->getKeyInfo(key_position).key_part;
+  const KeyPartInfo *end_key_part_found= key_part_found + getTable()->getShare()->getKeyInfo(key_position).key_parts;
   uint32_t length= 0;
 
   while (key_part_found < end_key_part_found && keypart_map_arg)
@@ -182,17 +182,17 @@
 
 bool Cursor::has_transactions()
 {
-  return (table->getShare()->db_type()->check_flag(HTON_BIT_DOES_TRANSACTIONS));
+  return (getTable()->getShare()->db_type()->check_flag(HTON_BIT_DOES_TRANSACTIONS));
 }
 
 void Cursor::ha_statistic_increment(uint64_t system_status_var::*offset) const
 {
-  (table->in_use->status_var.*offset)++;
+  (getTable()->in_use->status_var.*offset)++;
 }
 
 void **Cursor::ha_data(Session *session) const
 {
-  return session->getEngineData(engine);
+  return session->getEngineData(getEngine());
 }
 
 bool Cursor::is_fatal_error(int error, uint32_t flags)
@@ -208,7 +208,7 @@
 
 ha_rows Cursor::records() { return stats.records; }
 uint64_t Cursor::tableSize() { return stats.index_file_length + stats.data_file_length; }
-uint64_t Cursor::rowSize() { return table->getRecordLength() + table->sizeFields(); }
+uint64_t Cursor::rowSize() { return getTable()->getRecordLength() + getTable()->sizeFields(); }
 
 int Cursor::doOpen(const TableIdentifier &identifier, int mode, uint32_t test_if_locked)
 {
@@ -222,21 +222,17 @@
   Don't wait for locks if not HA_OPEN_WAIT_IF_LOCKED is set
 */
 int Cursor::ha_open(const TableIdentifier &identifier,
-                    Table *table_arg,
                     int mode,
                     int test_if_locked)
 {
   int error;
 
-  table= table_arg;
-  assert(table->getShare() == table_share);
-
   if ((error= doOpen(identifier, mode, test_if_locked)))
   {
     if ((error == EACCES || error == EROFS) && mode == O_RDWR &&
-        (table->db_stat & HA_TRY_READ_ONLY))
+        (getTable()->db_stat & HA_TRY_READ_ONLY))
     {
-      table->db_stat|=HA_READ_ONLY;
+      getTable()->db_stat|=HA_READ_ONLY;
       error= doOpen(identifier, O_RDONLY,test_if_locked);
     }
   }
@@ -246,12 +242,12 @@
   }
   else
   {
-    if (table->getShare()->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
-      table->db_stat|=HA_READ_ONLY;
+    if (getTable()->getShare()->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
+      getTable()->db_stat|=HA_READ_ONLY;
     (void) extra(HA_EXTRA_NO_READCHECK);	// Not needed in SQL
 
     /* ref is already allocated for us if we're called from Cursor::clone() */
-    if (!ref && !(ref= (unsigned char*) table->alloc_root(ALIGN_SIZE(ref_length)*2)))
+    if (!ref && !(ref= (unsigned char*) getTable()->alloc_root(ALIGN_SIZE(ref_length)*2)))
     {
       close();
       error=HA_ERR_OUT_OF_MEM;
@@ -280,7 +276,7 @@
     TODO remove the test for HA_READ_ORDER
   */
   if (stats.deleted < 10 || primary_key >= MAX_KEY ||
-      !(table->index_flags(primary_key) & HA_READ_ORDER))
+      !(getTable()->index_flags(primary_key) & HA_READ_ORDER))
   {
     (void) startTableScan(1);
     while ((error= rnd_next(buf)) == HA_ERR_RECORD_DELETED) ;
@@ -328,7 +324,7 @@
     Session::next_insert_id to be greater than the explicit value.
   */
   if ((next_insert_id > 0) && (nr >= next_insert_id))
-    set_next_insert_id(compute_next_insert_id(nr, &table->in_use->variables));
+    set_next_insert_id(compute_next_insert_id(nr, &getTable()->in_use->variables));
 }
 
 
@@ -445,7 +441,7 @@
 {
   uint64_t nr, nb_reserved_values;
   bool append= false;
-  Session *session= table->in_use;
+  Session *session= getTable()->in_use;
   struct system_variables *variables= &session->variables;
 
   /*
@@ -458,8 +454,8 @@
      for an auto increment column, not a magic value like NULL is.
      same as sql_mode=NO_AUTO_VALUE_ON_ZERO */
 
-  if ((nr= table->next_number_field->val_int()) != 0
-      || table->auto_increment_field_not_null)
+  if ((nr= getTable()->next_number_field->val_int()) != 0
+      || getTable()->auto_increment_field_not_null)
   {
     /*
       Update next_insert_id if we had already generated a value in this
@@ -537,14 +533,14 @@
       nr= compute_next_insert_id(nr-1, variables);
     }
 
-    if (table->getShare()->next_number_keypart == 0)
+    if (getTable()->getShare()->next_number_keypart == 0)
     {
       /* We must defer the appending until "nr" has been possibly truncated */
       append= true;
     }
   }
 
-  if (unlikely(table->next_number_field->store((int64_t) nr, true)))
+  if (unlikely(getTable()->next_number_field->store((int64_t) nr, true)))
   {
     /*
       first test if the query was aborted due to strict mode constraints
@@ -560,9 +556,9 @@
       bother shifting the right bound (anyway any other value from this
       interval will cause a duplicate key).
     */
-    nr= prev_insert_id(table->next_number_field->val_int(), variables);
-    if (unlikely(table->next_number_field->store((int64_t) nr, true)))
-      nr= table->next_number_field->val_int();
+    nr= prev_insert_id(getTable()->next_number_field->val_int(), variables);
+    if (unlikely(getTable()->next_number_field->store((int64_t) nr, true)))
+      nr= getTable()->next_number_field->val_int();
   }
   if (append)
   {
@@ -616,7 +612,7 @@
       this statement used forced auto_increment values if there were some,
       wipe them away for other statements.
     */
-    table->in_use->auto_inc_intervals_forced.empty();
+    getTable()->in_use->auto_inc_intervals_forced.empty();
   }
 }
 
@@ -662,10 +658,10 @@
    * possible resource to gain (and if there is... then there is a bug such
    * that in_use should have been set.
  */
-  if (not table || not table->in_use)
+  if (not getTable()->in_use)
     return;
 
-  resource_context= table->in_use->getResourceContext(engine);
+  resource_context= getTable()->in_use->getResourceContext(getEngine());
   /*
     When a storage engine method is called, the transaction must
     have been started, unless it's a DDL call, for which the
@@ -706,9 +702,9 @@
      * @todo Make TransactionServices generic to AfterTriggerServices
      * or similar...
      */
-    Session *const session= table->in_use;
+    Session *const session= getTable()->in_use;
     TransactionServices &transaction_services= TransactionServices::singleton();
-    transaction_services.truncateTable(session, table);
+    transaction_services.truncateTable(session, getTable());
   }
 
   return result;
@@ -807,7 +803,7 @@
   int error;
   if (!(error=index_next(buf)))
   {
-    ptrdiff_t ptrdiff= buf - table->getInsertRecord();
+    ptrdiff_t ptrdiff= buf - getTable()->getInsertRecord();
     unsigned char *save_record_0= NULL;
     KeyInfo *key_info= NULL;
     KeyPartInfo *key_part;
@@ -823,9 +819,9 @@
     */
     if (ptrdiff)
     {
-      save_record_0= table->getInsertRecord();
-      table->record[0]= buf;
-      key_info= table->key_info + active_index;
+      save_record_0= getTable()->getInsertRecord();
+      getTable()->record[0]= buf;
+      key_info= getTable()->key_info + active_index;
       key_part= key_info->key_part;
       key_part_end= key_part + key_info->key_parts;
       for (; key_part < key_part_end; key_part++)
@@ -835,16 +831,16 @@
       }
     }
 
-    if (key_cmp_if_same(table, key, active_index, keylen))
+    if (key_cmp_if_same(getTable(), key, active_index, keylen))
     {
-      table->status=STATUS_NOT_FOUND;
+      getTable()->status=STATUS_NOT_FOUND;
       error=HA_ERR_END_OF_FILE;
     }
 
     /* Move back if necessary. */
     if (ptrdiff)
     {
-      table->record[0]= save_record_0;
+      getTable()->record[0]= save_record_0;
       for (key_part= key_info->key_part; key_part < key_part_end; key_part++)
         key_part->field->move_field_offset(-ptrdiff);
     }
@@ -881,7 +877,7 @@
 double Cursor::index_only_read_time(uint32_t keynr, double key_records)
 {
   uint32_t keys_per_block= (stats.block_size/2/
-			(table->key_info[keynr].key_length + ref_length) + 1);
+			(getTable()->key_info[keynr].key_length + ref_length) + 1);
   return ((double) (key_records + keys_per_block-1) /
           (double) keys_per_block);
 }
@@ -1188,12 +1184,12 @@
     key_compare_result_on_equal= ((end_key->flag == HA_READ_BEFORE_KEY) ? 1 :
 				  (end_key->flag == HA_READ_AFTER_KEY) ? -1 : 0);
   }
-  range_key_part= table->key_info[active_index].key_part;
+  range_key_part= getTable()->key_info[active_index].key_part;
 
   if (!start_key)			// Read first record
-    result= index_first(table->getInsertRecord());
+    result= index_first(getTable()->getInsertRecord());
   else
-    result= index_read_map(table->getInsertRecord(),
+    result= index_read_map(getTable()->getInsertRecord(),
                            start_key->key,
                            start_key->keypart_map,
                            start_key->flag);
@@ -1226,11 +1222,11 @@
   if (eq_range)
   {
     /* We trust that index_next_same always gives a row in range */
-    return(index_next_same(table->getInsertRecord(),
+    return(index_next_same(getTable()->getInsertRecord(),
                                 end_range->key,
                                 end_range->length));
   }
-  result= index_next(table->getInsertRecord());
+  result= index_next(getTable()->getInsertRecord());
   if (result)
     return result;
   return(compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
@@ -1398,18 +1394,18 @@
   {
     if (lock_type == F_RDLCK)
     {
-      DRIZZLE_CURSOR_RDLOCK_START(table_share->getSchemaName(),
-                                  table_share->getTableName());
+      DRIZZLE_CURSOR_RDLOCK_START(getTable()->getShare()->getSchemaName(),
+                                  getTable()->getShare()->getTableName());
     }
     else if (lock_type == F_WRLCK)
     {
-      DRIZZLE_CURSOR_WRLOCK_START(table_share->getSchemaName(),
-                                  table_share->getTableName());
+      DRIZZLE_CURSOR_WRLOCK_START(getTable()->getShare()->getSchemaName(),
+                                  getTable()->getShare()->getTableName());
     }
     else if (lock_type == F_UNLCK)
     {
-      DRIZZLE_CURSOR_UNLOCK_START(table_share->getSchemaName(),
-                                  table_share->getTableName());
+      DRIZZLE_CURSOR_UNLOCK_START(getTable()->getShare()->getSchemaName(),
+                                  getTable()->getShare()->getTableName());
     }
   }
 
@@ -1448,14 +1444,14 @@
 int Cursor::ha_reset()
 {
   /* Check that we have called all proper deallocation functions */
-  assert(! table->getShare()->all_set.none());
-  assert(table->key_read == 0);
+  assert(! getTable()->getShare()->all_set.none());
+  assert(getTable()->key_read == 0);
   /* ensure that ha_index_end / endTableScan has been called */
   assert(inited == NONE);
   /* Free cache used by filesort */
-  table->free_io_cache();
+  getTable()->free_io_cache();
   /* reset the bitmaps to point to defaults */
-  table->default_column_bitmaps();
+  getTable()->default_column_bitmaps();
   return(reset());
 }
 
@@ -1470,22 +1466,22 @@
    * @TODO Technically, the below two lines can be take even further out of the
    * Cursor interface and into the fill_record() method.
    */
-  if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
+  if (getTable()->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
   {
-    table->timestamp_field->set_time();
+    getTable()->timestamp_field->set_time();
   }
 
-  DRIZZLE_INSERT_ROW_START(table_share->getSchemaName(), table_share->getTableName());
+  DRIZZLE_INSERT_ROW_START(getTable()->getShare()->getSchemaName(), getTable()->getShare()->getTableName());
   setTransactionReadWrite();
   
-  if (unlikely(plugin::EventObserver::beforeInsertRecord(*table, buf)))
+  if (unlikely(plugin::EventObserver::beforeInsertRecord(*getTable(), buf)))
   {
     error= ER_EVENT_OBSERVER_PLUGIN;
   }
   else
   {
     error= doInsertRecord(buf);
-    if (unlikely(plugin::EventObserver::afterInsertRecord(*table, buf, error))) 
+    if (unlikely(plugin::EventObserver::afterInsertRecord(*getTable(), buf, error))) 
     {
       error= ER_EVENT_OBSERVER_PLUGIN;
     }
@@ -1500,7 +1496,7 @@
     return error;
   }
 
-  if (unlikely(log_row_for_replication(table, NULL, buf)))
+  if (unlikely(log_row_for_replication(getTable(), NULL, buf)))
     return HA_ERR_RBR_LOGGING_FAILED;
 
   return 0;
@@ -1515,23 +1511,23 @@
     Some storage engines require that the new record is in getInsertRecord()
     (and the old record is in getUpdateRecord()).
    */
-  assert(new_data == table->getInsertRecord());
+  assert(new_data == getTable()->getInsertRecord());
 
-  DRIZZLE_UPDATE_ROW_START(table_share->getSchemaName(), table_share->getTableName());
+  DRIZZLE_UPDATE_ROW_START(getTable()->getShare()->getSchemaName(), getTable()->getShare()->getTableName());
   setTransactionReadWrite();
-  if (unlikely(plugin::EventObserver::beforeUpdateRecord(*table, old_data, new_data)))
+  if (unlikely(plugin::EventObserver::beforeUpdateRecord(*getTable(), old_data, new_data)))
   {
     error= ER_EVENT_OBSERVER_PLUGIN;
   }
   else
   {
-    if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
+    if (getTable()->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
     {
-      table->timestamp_field->set_time();
+      getTable()->timestamp_field->set_time();
     }
 
     error= doUpdateRecord(old_data, new_data);
-    if (unlikely(plugin::EventObserver::afterUpdateRecord(*table, old_data, new_data, error)))
+    if (unlikely(plugin::EventObserver::afterUpdateRecord(*getTable(), old_data, new_data, error)))
     {
       error= ER_EVENT_OBSERVER_PLUGIN;
     }
@@ -1546,26 +1542,30 @@
     return error;
   }
 
-  if (unlikely(log_row_for_replication(table, old_data, new_data)))
+  if (unlikely(log_row_for_replication(getTable(), old_data, new_data)))
     return HA_ERR_RBR_LOGGING_FAILED;
 
   return 0;
 }
+TableShare *Cursor::getShare()
+{
+  return getTable()->getMutableShare();
+}
 
 int Cursor::deleteRecord(const unsigned char *buf)
 {
   int error;
 
-  DRIZZLE_DELETE_ROW_START(table_share->getSchemaName(), table_share->getTableName());
+  DRIZZLE_DELETE_ROW_START(getTable()->getShare()->getSchemaName(), getTable()->getShare()->getTableName());
   setTransactionReadWrite();
-  if (unlikely(plugin::EventObserver::beforeDeleteRecord(*table, buf)))
+  if (unlikely(plugin::EventObserver::beforeDeleteRecord(*getTable(), buf)))
   {
     error= ER_EVENT_OBSERVER_PLUGIN;
   }
   else
   {
     error= doDeleteRecord(buf);
-    if (unlikely(plugin::EventObserver::afterDeleteRecord(*table, buf, error)))
+    if (unlikely(plugin::EventObserver::afterDeleteRecord(*getTable(), buf, error)))
     {
       error= ER_EVENT_OBSERVER_PLUGIN;
     }
@@ -1578,7 +1578,7 @@
   if (unlikely(error))
     return error;
 
-  if (unlikely(log_row_for_replication(table, buf, NULL)))
+  if (unlikely(log_row_for_replication(getTable(), buf, NULL)))
     return HA_ERR_RBR_LOGGING_FAILED;
 
   return 0;

=== modified file 'drizzled/cursor.h'
--- drizzled/cursor.h	2010-10-22 00:20:21 +0000
+++ drizzled/cursor.h	2010-10-23 00:16:13 +0000
@@ -145,23 +145,25 @@
 */
 class Cursor
 {
+  Table &table;               /* The current open table */
+  plugin::StorageEngine &engine;      /* storage engine of this Cursor */
+
 protected:
-  TableShare *table_share;   /* The table definition */
-  Table *table;               /* The current open table */
-
   ha_rows estimation_rows_to_insert;
-  plugin::StorageEngine *engine;      /* storage engine of this Cursor */
+
 public:
   inline plugin::StorageEngine *getEngine() const	/* table_type for handler */
   {
-    return engine;
+    return &engine;
   }
   unsigned char *ref;				/* Pointer to current row */
   unsigned char *dup_ref;			/* Pointer to duplicate row */
 
-  TableShare *getShare() const
+  TableShare *getShare();
+
+  Table *getTable() const
   {
-    return table_share;
+    return &table;
   }
 
   ha_statistics stats;
@@ -222,13 +224,13 @@
   */
   Discrete_interval auto_inc_interval_for_cur_row;
 
-  Cursor(plugin::StorageEngine &engine_arg, TableShare &share_arg);
+  Cursor(plugin::StorageEngine &engine_arg, Table &share_arg);
   virtual ~Cursor(void);
   virtual Cursor *clone(memory::Root *mem_root);
 
   /* ha_ methods: pubilc wrappers for private virtual API */
 
-  int ha_open(const TableIdentifier &identifier, Table *table, int mode, int test_if_locked);
+  int ha_open(const TableIdentifier &identifier, int mode, int test_if_locked);
   int startIndexScan(uint32_t idx, bool sorted);
   int endIndexScan();
   int startTableScan(bool scan);

=== modified file 'drizzled/memory/root.cc'
--- drizzled/memory/root.cc	2010-10-02 21:15:42 +0000
+++ drizzled/memory/root.cc	2010-10-23 00:16:13 +0000
@@ -61,6 +61,10 @@
   first_block_usage= 0;
 }
 
+memory::Root::~Root()
+{
+}
+
 
 /**
  * @details

=== modified file 'drizzled/memory/root.h'
--- drizzled/memory/root.h	2010-10-02 21:15:42 +0000
+++ drizzled/memory/root.h	2010-10-23 00:16:13 +0000
@@ -85,6 +85,8 @@
     error_handler= 0;
   }
 
+  ~Root();
+
   /**
    * blocks with free memory in it 
    */

=== modified file 'drizzled/plugin/storage_engine.cc'
--- drizzled/plugin/storage_engine.cc	2010-10-20 01:27:24 +0000
+++ drizzled/plugin/storage_engine.cc	2010-10-23 00:16:13 +0000
@@ -545,9 +545,9 @@
   return(error != 0);
 }
 
-Cursor *StorageEngine::getCursor(TableShare &share)
+Cursor *StorageEngine::getCursor(Table &arg)
 {
-  return create(share);
+  return create(arg);
 }
 
 class AddTableIdentifier : 

=== modified file 'drizzled/plugin/storage_engine.h'
--- drizzled/plugin/storage_engine.h	2010-10-09 01:10:07 +0000
+++ drizzled/plugin/storage_engine.h	2010-10-23 00:16:13 +0000
@@ -251,7 +251,7 @@
   {
     return 0;
   }
-  virtual Cursor *create(TableShare &)= 0;
+  virtual Cursor *create(Table &)= 0;
   /* args: path */
   virtual bool flush_logs() { return false; }
   virtual bool show_status(Session *, stat_print_fn *, enum ha_stat_type)
@@ -365,7 +365,7 @@
 
   static void removeLostTemporaryTables(Session &session, const char *directory);
 
-  Cursor *getCursor(TableShare &share);
+  Cursor *getCursor(Table &share);
 
   uint32_t max_record_length() const
   { return std::min((unsigned int)HA_MAX_REC_LENGTH, max_supported_record_length()); }

=== modified file 'drizzled/table.cc'
--- drizzled/table.cc	2010-10-21 20:56:58 +0000
+++ drizzled/table.cc	2010-10-23 00:16:13 +0000
@@ -1063,7 +1063,7 @@
       (select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) == OPTION_BIG_TABLES)
   {
     table->getMutableShare()->storage_engine= myisam_engine;
-    table->cursor= table->getMutableShare()->db_type()->getCursor(*table->getMutableShare());
+    table->cursor= table->getMutableShare()->db_type()->getCursor(*table);
     if (group &&
 	(param->group_parts > table->cursor->getEngine()->max_key_parts() ||
 	 param->group_length > table->cursor->getEngine()->max_key_length()))
@@ -1074,7 +1074,7 @@
   else
   {
     table->getMutableShare()->storage_engine= heap_engine;
-    table->cursor= table->getMutableShare()->db_type()->getCursor(*table->getMutableShare());
+    table->cursor= table->getMutableShare()->db_type()->getCursor(*table);
   }
   if (! table->cursor)
     goto err;

=== modified file 'drizzled/table/instance.cc'
--- drizzled/table/instance.cc	2010-10-21 08:01:16 +0000
+++ drizzled/table/instance.cc	2010-10-23 00:16:13 +0000
@@ -42,7 +42,6 @@
   
   TableIdentifier identifier(getShare()->getSchemaName(), getShare()->getTableName(), getShare()->getPath());
   if ((error=cursor->ha_open(identifier,
-                             this,
                              O_RDWR,
                              HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))
   {

=== modified file 'drizzled/table_share.cc'
--- drizzled/table_share.cc	2010-10-22 00:26:57 +0000
+++ drizzled/table_share.cc	2010-10-23 00:16:13 +0000
@@ -1873,7 +1873,7 @@
   outparam.setAlias(alias);
 
   /* Allocate Cursor */
-  if (not (outparam.cursor= db_type()->getCursor(*this)))
+  if (not (outparam.cursor= db_type()->getCursor(outparam)))
     return local_error;
 
   local_error= 4;
@@ -2011,9 +2011,9 @@
     assert(!(db_stat & HA_WAIT_IF_LOCKED));
     int ha_err;
 
-    if ((ha_err= (outparam.cursor->ha_open(identifier, &outparam,
-                          (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
-                          (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE : HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
+    if ((ha_err= (outparam.cursor->ha_open(identifier,
+                                           (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
+                                           (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE : HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
     {
       switch (ha_err)
       {

=== modified file 'plugin/archive/archive_engine.h'
--- plugin/archive/archive_engine.h	2010-10-02 21:15:42 +0000
+++ plugin/archive/archive_engine.h	2010-10-23 00:16:13 +0000
@@ -87,7 +87,7 @@
     return _mutex;
   }
 
-  virtual drizzled::Cursor *create(drizzled::TableShare &table)
+  virtual drizzled::Cursor *create(drizzled::Table &table)
   {
     return new ha_archive(*this, table);
   }

=== modified file 'plugin/archive/ha_archive.cc'
--- plugin/archive/ha_archive.cc	2010-10-02 21:15:42 +0000
+++ plugin/archive/ha_archive.cc	2010-10-23 00:16:13 +0000
@@ -196,7 +196,7 @@
 
 
 ha_archive::ha_archive(drizzled::plugin::StorageEngine &engine_arg,
-                       TableShare &table_arg)
+                       Table &table_arg)
   :Cursor(engine_arg, table_arg), delayed_insert(0), bulk_insert(0)
 {
   /* Set our original buffer from pre-allocated memory */
@@ -294,7 +294,7 @@
 */
 ArchiveShare *ha_archive::get_share(const char *table_name, int *rc)
 {
-  ArchiveEngine *a_engine= static_cast<ArchiveEngine *>(engine);
+  ArchiveEngine *a_engine= static_cast<ArchiveEngine *>(getEngine());
 
   pthread_mutex_lock(&a_engine->mutex());
 
@@ -339,7 +339,7 @@
 */
 int ha_archive::free_share()
 {
-  ArchiveEngine *a_engine= static_cast<ArchiveEngine *>(engine);
+  ArchiveEngine *a_engine= static_cast<ArchiveEngine *>(getEngine());
 
   pthread_mutex_lock(&a_engine->mutex());
   if (!--share->use_count)
@@ -438,7 +438,7 @@
 
   assert(share);
 
-  record_buffer.resize(table->getShare()->getRecordLength() + ARCHIVE_ROW_HEADER_SIZE);
+  record_buffer.resize(getTable()->getShare()->getRecordLength() + ARCHIVE_ROW_HEADER_SIZE);
 
   lock.init(&share->_lock);
 
@@ -624,15 +624,15 @@
 
 uint32_t ha_archive::max_row_length(const unsigned char *)
 {
-  uint32_t length= (uint32_t)(table->getRecordLength() + table->sizeFields()*2);
+  uint32_t length= (uint32_t)(getTable()->getRecordLength() + getTable()->sizeFields()*2);
   length+= ARCHIVE_ROW_HEADER_SIZE;
 
   uint32_t *ptr, *end;
-  for (ptr= table->getBlobField(), end=ptr + table->sizeBlobFields();
+  for (ptr= getTable()->getBlobField(), end=ptr + getTable()->sizeBlobFields();
        ptr != end ;
        ptr++)
   {
-      length += 2 + ((Field_blob*)table->getField(*ptr))->get_length();
+      length += 2 + ((Field_blob*)getTable()->getField(*ptr))->get_length();
   }
 
   return length;
@@ -647,10 +647,10 @@
     return(HA_ERR_OUT_OF_MEM);
 
   /* Copy null bits */
-  memcpy(&record_buffer[0], record, table->getShare()->null_bytes);
-  ptr= &record_buffer[0] + table->getShare()->null_bytes;
+  memcpy(&record_buffer[0], record, getTable()->getShare()->null_bytes);
+  ptr= &record_buffer[0] + getTable()->getShare()->null_bytes;
 
-  for (Field **field=table->getFields() ; *field ; field++)
+  for (Field **field=getTable()->getFields() ; *field ; field++)
   {
     if (!((*field)->is_null()))
       ptr= (*field)->pack(ptr, record + (*field)->offset(record));
@@ -674,7 +674,7 @@
   int rc;
   unsigned char *read_buf= NULL;
   uint64_t temp_auto;
-  unsigned char *record=  table->getInsertRecord();
+  unsigned char *record=  getTable()->getInsertRecord();
 
   if (share->crashed)
     return(HA_ERR_CRASHED_ON_USAGE);
@@ -686,17 +686,17 @@
       return(HA_ERR_CRASHED_ON_USAGE);
 
 
-  if (table->next_number_field && record == table->getInsertRecord())
+  if (getTable()->next_number_field && record == getTable()->getInsertRecord())
   {
     update_auto_increment();
-    temp_auto= table->next_number_field->val_int();
+    temp_auto= getTable()->next_number_field->val_int();
 
     /*
       We don't support decremening auto_increment. They make the performance
       just cry.
     */
     if (temp_auto <= share->archive_write.auto_increment &&
-        table->getShare()->getKeyInfo(0).flags & HA_NOSAME)
+        getTable()->getShare()->getKeyInfo(0).flags & HA_NOSAME)
     {
       rc= HA_ERR_FOUND_DUPP_KEY;
       goto error;
@@ -748,7 +748,7 @@
 {
   int rc;
   bool found= 0;
-  current_k_offset= table->getShare()->getKeyInfo(0).key_part->offset;
+  current_k_offset= getTable()->getShare()->getKeyInfo(0).key_part->offset;
   current_key= key;
   current_key_len= key_len;
 
@@ -853,13 +853,13 @@
   }
 
   /* Copy null bits */
-  memcpy(record, ptr, table->getNullBytes());
-  ptr+= table->getNullBytes();
-  for (Field **field= table->getFields() ; *field ; field++)
+  memcpy(record, ptr, getTable()->getNullBytes());
+  ptr+= getTable()->getNullBytes();
+  for (Field **field= getTable()->getFields() ; *field ; field++)
   {
     if (!((*field)->is_null()))
     {
-      ptr= (*field)->unpack(record + (*field)->offset(table->getInsertRecord()), ptr);
+      ptr= (*field)->unpack(record + (*field)->offset(getTable()->getInsertRecord()), ptr);
     }
   }
   return(0);
@@ -894,7 +894,7 @@
   current_position= aztell(&archive);
   rc= get_row(&archive, buf);
 
-  table->status=rc ? STATUS_NOT_FOUND: 0;
+  getTable()->status=rc ? STATUS_NOT_FOUND: 0;
 
   return(rc);
 }
@@ -1014,26 +1014,26 @@
 
       for (uint64_t x= 0; x < rows_restored ; x++)
       {
-        rc= get_row(&archive, table->getInsertRecord());
+        rc= get_row(&archive, getTable()->getInsertRecord());
 
         if (rc != 0)
           break;
 
-        real_write_row(table->getInsertRecord(), &writer);
+        real_write_row(getTable()->getInsertRecord(), &writer);
         /*
           Long term it should be possible to optimize this so that
           it is not called on each row.
         */
-        if (table->found_next_number_field)
+        if (getTable()->found_next_number_field)
         {
-          Field *field= table->found_next_number_field;
+          Field *field= getTable()->found_next_number_field;
 
           /* Since we will need to use field to translate, we need to flip its read bit */
           field->setReadSet();
 
           uint64_t auto_value=
-            (uint64_t) field->val_int(table->getInsertRecord() +
-                                       field->offset(table->getInsertRecord()));
+            (uint64_t) field->val_int(getTable()->getInsertRecord() +
+                                       field->offset(getTable()->getInsertRecord()));
           if (share->archive_write.auto_increment < auto_value)
             stats.auto_increment_value=
               (share->archive_write.auto_increment= auto_value) + 1;
@@ -1147,7 +1147,7 @@
 
     stat(share->data_file_name.c_str(), &file_stat);
 
-    stats.mean_rec_length= table->getRecordLength()+ buffer.alloced_length();
+    stats.mean_rec_length= getTable()->getRecordLength()+ buffer.alloced_length();
     stats.data_file_length= file_stat.st_size;
     stats.create_time= file_stat.st_ctime;
     stats.update_time= file_stat.st_mtime;
@@ -1229,7 +1229,7 @@
   read_data_header(&archive);
   for (uint64_t x= 0; x < share->archive_write.rows; x++)
   {
-    rc= get_row(&archive, table->getInsertRecord());
+    rc= get_row(&archive, getTable()->getInsertRecord());
 
     if (rc != 0)
       break;

=== modified file 'plugin/archive/ha_archive.h'
--- plugin/archive/ha_archive.h	2010-10-02 21:15:42 +0000
+++ plugin/archive/ha_archive.h	2010-10-23 00:16:13 +0000
@@ -79,7 +79,7 @@
 
 public:
   ha_archive(drizzled::plugin::StorageEngine &engine_arg,
-             drizzled::TableShare &table_arg);
+             drizzled::Table &table_arg);
   ~ha_archive()
   { }
 

=== modified file 'plugin/blackhole/ha_blackhole.cc'
--- plugin/blackhole/ha_blackhole.cc	2010-10-02 21:15:42 +0000
+++ plugin/blackhole/ha_blackhole.cc	2010-10-23 00:16:13 +0000
@@ -68,7 +68,7 @@
     pthread_mutex_destroy(&blackhole_mutex);
   }
 
-  virtual Cursor *create(TableShare &table)
+  virtual Cursor *create(Table &table)
   {
     return new ha_blackhole(*this, table);
   }
@@ -191,7 +191,7 @@
 *****************************************************************************/
 
 ha_blackhole::ha_blackhole(drizzled::plugin::StorageEngine &engine_arg,
-                           TableShare &table_arg)
+                           Table &table_arg)
   :Cursor(engine_arg, table_arg), share(NULL)
 { }
 
@@ -318,7 +318,7 @@
 
 int ha_blackhole::doInsertRecord(unsigned char *)
 {
-  return(table->next_number_field ? update_auto_increment() : 0);
+  return(getTable()->next_number_field ? update_auto_increment() : 0);
 }
 
 int ha_blackhole::doStartTableScan(bool)
@@ -404,7 +404,7 @@
 {
   pthread_mutex_lock(&blackhole_mutex);
 
-  BlackholeEngine *a_engine= static_cast<BlackholeEngine *>(engine);
+  BlackholeEngine *a_engine= static_cast<BlackholeEngine *>(getEngine());
   share= a_engine->findOpenTable(table_name);
 
   if (share == NULL)
@@ -429,7 +429,7 @@
   pthread_mutex_lock(&blackhole_mutex);
   if (!--share->use_count)
   {
-    BlackholeEngine *a_engine= static_cast<BlackholeEngine *>(engine);
+    BlackholeEngine *a_engine= static_cast<BlackholeEngine *>(getEngine());
     a_engine->deleteOpenTable(share->table_name);
     delete share;
   }

=== modified file 'plugin/blackhole/ha_blackhole.h'
--- plugin/blackhole/ha_blackhole.h	2010-10-02 21:15:42 +0000
+++ plugin/blackhole/ha_blackhole.h	2010-10-23 00:16:13 +0000
@@ -51,7 +51,7 @@
 
 public:
   ha_blackhole(drizzled::plugin::StorageEngine &engine,
-               drizzled::TableShare &table_arg);
+               drizzled::Table &table_arg);
   ~ha_blackhole()
   {}
 

=== modified file 'plugin/blitzdb/blitzcmp.cc'
--- plugin/blitzdb/blitzcmp.cc	2010-10-12 02:56:36 +0000
+++ plugin/blitzdb/blitzcmp.cc	2010-10-23 00:16:13 +0000
@@ -35,7 +35,7 @@
   /* For now, we are only interested in supporting a PRIMARY KEY. In the
      next phase of BlitzDB, this should loop through the key array. */
   if (share->primary_key_exists) {
-    KeyInfo *pk = &table->key_info[table->getShare()->getPrimaryKey()];
+    KeyInfo *pk = &getTable()->key_info[getTable()->getShare()->getPrimaryKey()];
     KeyPartInfo *key_part = pk->key_part;
     KeyPartInfo *key_part_end = key_part + pk->key_parts;
     int key_changed = 0;
@@ -67,13 +67,13 @@
        would violate the unique contraint. */
     if (key_changed) {
       key = key_buffer;
-      key_len = make_index_key(key, table->getMutableShare()->getPrimaryKey(), new_row);
+      key_len = make_index_key(key, getTable()->getMutableShare()->getPrimaryKey(), new_row);
       fetched = share->dict.get_row(key, key_len, &fetched_len);
 
       /* Key Exists. It's a violation. */
       if (fetched != NULL) {
         free(fetched);
-        this->errkey_id = table->getShare()->getPrimaryKey();
+        this->errkey_id = getTable()->getShare()->getPrimaryKey();
         return HA_ERR_FOUND_DUPP_KEY;
       }
     }

=== modified file 'plugin/blitzdb/ha_blitz.cc'
--- plugin/blitzdb/ha_blitz.cc	2010-10-12 02:56:36 +0000
+++ plugin/blitzdb/ha_blitz.cc	2010-10-23 00:16:13 +0000
@@ -54,7 +54,7 @@
     tcmapdel(blitz_table_cache);
   }
 
-  virtual drizzled::Cursor *create(drizzled::TableShare &table) {
+  virtual drizzled::Cursor *create(drizzled::Table &table) {
     return new ha_blitz(*this, table);
   }
 
@@ -365,7 +365,7 @@
 }
 
 ha_blitz::ha_blitz(drizzled::plugin::StorageEngine &engine_arg,
-                   TableShare &table_arg) : Cursor(engine_arg, table_arg),
+                   Table &table_arg) : Cursor(engine_arg, table_arg),
                                             btree_cursor(NULL),
                                             table_scan(false),
                                             table_based(false),
@@ -421,7 +421,7 @@
      will use to uniquely identify a row. The actual allocation is
      done by the kernel so all we do here is specify the size of it.*/
   if (share->primary_key_exists) {
-    ref_length = table->key_info[table->getShare()->getPrimaryKey()].key_length;
+    ref_length = getTable()->key_info[getTable()->getShare()->getPrimaryKey()].key_length;
   } else {
     ref_length = sizeof(held_key_len) + sizeof(uint64_t);
   }
@@ -460,7 +460,7 @@
 
 int ha_blitz::doStartTableScan(bool scan) {
   /* Obtain the query type for this scan */
-  sql_command_type = session_sql_command(table->getSession());
+  sql_command_type = session_sql_command(getTable()->getSession());
   table_scan = scan;
   table_based = true;
 
@@ -488,7 +488,7 @@
   held_key = NULL;
 
   if (current_key == NULL) {
-    table->status = STATUS_NOT_FOUND;
+    getTable()->status = STATUS_NOT_FOUND;
     return HA_ERR_END_OF_FILE;
   }
 
@@ -519,7 +519,7 @@
   /* It is now memory-leak-safe to point current_key to next_key. */
   current_key = next_key;
   current_key_len = next_key_len;
-  table->status = 0;
+  getTable()->status = 0;
   return 0;
 }
 
@@ -585,7 +585,7 @@
 
 int ha_blitz::doStartIndexScan(uint32_t key_num, bool) {
   active_index = key_num;
-  sql_command_type = session_sql_command(table->getSession());
+  sql_command_type = session_sql_command(getTable()->getSession());
 
   /* This is unlikely to happen but just for assurance, re-obtain
      the lock if this thread already has a certain lock. This makes
@@ -630,7 +630,7 @@
   bt_key = btree_cursor[active_index].next_key(&bt_klen);
 
   if (bt_key == NULL) {
-    table->status = STATUS_NOT_FOUND;
+    getTable()->status = STATUS_NOT_FOUND;
     return HA_ERR_END_OF_FILE;
   }
 
@@ -639,7 +639,7 @@
 
   if ((row = share->dict.get_row(dict_key, dict_klen, &rlen)) == NULL) {
     free(bt_key);
-    table->status = STATUS_NOT_FOUND;
+    getTable()->status = STATUS_NOT_FOUND;
     return HA_ERR_KEY_NOT_FOUND;
   }
 
@@ -794,14 +794,14 @@
   ha_statistic_increment(&system_status_var::ha_write_count);
 
   /* Prepare Auto Increment field if one exists. */
-  if (table->next_number_field && drizzle_row == table->getInsertRecord()) {
+  if (getTable()->next_number_field && drizzle_row == getTable()->getInsertRecord()) {
     pthread_mutex_lock(&blitz_utility_mutex);
     if ((rv = update_auto_increment()) != 0) {
       pthread_mutex_unlock(&blitz_utility_mutex);
       return rv;
     }
 
-    uint64_t next_val = table->next_number_field->val_int();
+    uint64_t next_val = getTable()->next_number_field->val_int();
 
     if (next_val > share->auto_increment_value) {
       share->auto_increment_value = next_val;
@@ -932,7 +932,7 @@
       /* Now write the new key. */
       prefix_len = make_index_key(key_buffer, i, new_row);
 
-      if (i == table->getShare()->getPrimaryKey()) {
+      if (i == getTable()->getShare()->getPrimaryKey()) {
         key = merge_key(key_buffer, prefix_len, key_buffer, prefix_len, &klen);
         rv = share->btrees[i].write(key, klen);
       } else {
@@ -959,13 +959,13 @@
   if (table_based) {
     rv = share->dict.write_row(held_key, held_key_len, row_buf, row_len);
   } else {
-    int klen = make_index_key(key_buffer, table->getShare()->getPrimaryKey(), old_row);
+    int klen = make_index_key(key_buffer, getTable()->getShare()->getPrimaryKey(), old_row);
 
     /* Delete with the old key. */
     share->dict.delete_row(key_buffer, klen);
 
     /* Write with the new key. */
-    klen = make_index_key(key_buffer, table->getShare()->getPrimaryKey(), new_row);
+    klen = make_index_key(key_buffer, getTable()->getShare()->getPrimaryKey(), new_row);
     rv = share->dict.write_row(key_buffer, klen, row_buf, row_len);
   }
 
@@ -1057,12 +1057,12 @@
 }
 
 uint32_t ha_blitz::max_row_length(void) {
-  uint32_t length = (table->getRecordLength() + table->sizeFields() * 2);
-  uint32_t *pos = table->getBlobField();
-  uint32_t *end = pos + table->sizeBlobFields();
+  uint32_t length = (getTable()->getRecordLength() + getTable()->sizeFields() * 2);
+  uint32_t *pos = getTable()->getBlobField();
+  uint32_t *end = pos + getTable()->sizeBlobFields();
 
   while (pos != end) {
-    length += 2 + ((Field_blob *)table->getField(*pos))->get_length();
+    length += 2 + ((Field_blob *)getTable()->getField(*pos))->get_length();
     pos++;
   }
 
@@ -1079,12 +1079,12 @@
   /* Getting here means that there is a PK in this table. Get the
      binary representation of the PK, pack it to BlitzDB's key buffer
      and return the size of it. */
-  return make_index_key(pack_to, table->getShare()->getPrimaryKey(), row);
+  return make_index_key(pack_to, getTable()->getShare()->getPrimaryKey(), row);
 }
 
 size_t ha_blitz::make_index_key(char *pack_to, int key_num,
                                 const unsigned char *row) {
-  KeyInfo *key = &table->key_info[key_num];
+  KeyInfo *key = &getTable()->key_info[key_num];
   KeyPartInfo *key_part = key->key_part;
   KeyPartInfo *key_part_end = key_part + key->key_parts;
 
@@ -1145,7 +1145,7 @@
 }
 
 size_t ha_blitz::btree_key_length(const char *key, const int key_num) {
-  KeyInfo *key_info = &table->key_info[key_num];
+  KeyInfo *key_info = &getTable()->key_info[key_num];
   KeyPartInfo *key_part = key_info->key_part;
   KeyPartInfo *key_part_end = key_part + key_info->key_parts;
   char *pos = (char *)key;
@@ -1185,7 +1185,7 @@
 /* Converts a native Drizzle index key to BlitzDB's format. */
 char *ha_blitz::native_to_blitz_key(const unsigned char *native_key,
                                     const int key_num, int *return_key_len) {
-  KeyInfo *key = &table->key_info[key_num];
+  KeyInfo *key = &getTable()->key_info[key_num];
   KeyPartInfo *key_part = key->key_part;
   KeyPartInfo *key_part_end = key_part + key->key_parts;
 
@@ -1240,16 +1240,16 @@
 
   /* Nothing special to do if the table is fixed length */
   if (share->fixed_length_table) {
-    memcpy(row_buffer, row_to_pack, table->getShare()->getRecordLength());
-    return (size_t)table->getShare()->getRecordLength();
+    memcpy(row_buffer, row_to_pack, getTable()->getShare()->getRecordLength());
+    return (size_t)getTable()->getShare()->getRecordLength();
   }
 
   /* Copy NULL bits */
-  memcpy(row_buffer, row_to_pack, table->getShare()->null_bytes);
-  pos = row_buffer + table->getShare()->null_bytes;
+  memcpy(row_buffer, row_to_pack, getTable()->getShare()->null_bytes);
+  pos = row_buffer + getTable()->getShare()->null_bytes;
 
   /* Pack each field into the buffer */
-  for (Field **field = table->getFields(); *field; field++) {
+  for (Field **field = getTable()->getFields(); *field; field++) {
     if (!((*field)->is_null()))
       pos = (*field)->pack(pos, row_to_pack + (*field)->offset(row_to_pack));
   }
@@ -1270,13 +1270,13 @@
   /* Start by copying NULL bits which is the beginning block
      of a Drizzle row. */
   pos = (const unsigned char *)from;
-  memcpy(to, pos, table->getShare()->null_bytes);
-  pos += table->getShare()->null_bytes;
+  memcpy(to, pos, getTable()->getShare()->null_bytes);
+  pos += getTable()->getShare()->null_bytes;
 
   /* Unpack all fields in the provided row. */
-  for (Field **field = table->getFields(); *field; field++) {
+  for (Field **field = getTable()->getFields(); *field; field++) {
     if (!((*field)->is_null())) {
-      pos = (*field)->unpack(to + (*field)->offset(table->getInsertRecord()), pos);
+      pos = (*field)->unpack(to + (*field)->offset(getTable()->getInsertRecord()), pos);
     }
   }
 
@@ -1308,7 +1308,7 @@
 
 BlitzShare *ha_blitz::get_share(const char *name) {
   BlitzShare *share_ptr;
-  BlitzEngine *bz_engine = (BlitzEngine *)engine;
+  BlitzEngine *bz_engine = (BlitzEngine *)getEngine();
   std::string table_path(name);
 
   pthread_mutex_lock(&blitz_utility_mutex);
@@ -1333,14 +1333,14 @@
   }
 
   /* Prepare Index Structure(s) */
-  KeyInfo *curr = &table->getMutableShare()->getKeyInfo(0);
-  share_ptr->btrees = new BlitzTree[table->getShare()->keys];
+  KeyInfo *curr = &getTable()->getMutableShare()->getKeyInfo(0);
+  share_ptr->btrees = new BlitzTree[getTable()->getShare()->keys];
 
-  for (uint32_t i = 0; i < table->getShare()->keys; i++, curr++) {
+  for (uint32_t i = 0; i < getTable()->getShare()->keys; i++, curr++) {
     share_ptr->btrees[i].open(table_path.c_str(), i, BDBOWRITER);
     share_ptr->btrees[i].parts = new BlitzKeyPart[curr->key_parts];
 
-    if (table->key_info[i].flags & HA_NOSAME)
+    if (getTable()->key_info[i].flags & HA_NOSAME)
       share_ptr->btrees[i].unique = true;
 
     share_ptr->btrees[i].length = curr->key_length;
@@ -1353,7 +1353,7 @@
       if (f->null_ptr) {
         share_ptr->btrees[i].parts[j].null_bitmask = f->null_bit;
         share_ptr->btrees[i].parts[j].null_pos
-          = (uint32_t)(f->null_ptr - (unsigned char *)table->getInsertRecord());
+          = (uint32_t)(f->null_ptr - (unsigned char *)getTable()->getInsertRecord());
       }
 
       share_ptr->btrees[i].parts[j].flag = curr->key_part[j].key_part_flag;
@@ -1371,13 +1371,13 @@
   /* Set Meta Data */
   share_ptr->auto_increment_value = share_ptr->dict.read_meta_autoinc();
   share_ptr->table_name = table_path;
-  share_ptr->nkeys = table->getShare()->keys;
+  share_ptr->nkeys = getTable()->getShare()->keys;
   share_ptr->use_count = 1;
 
-  share_ptr->fixed_length_table = !(table->getShare()->db_create_options
+  share_ptr->fixed_length_table = !(getTable()->getShare()->db_create_options
                                     & HA_OPTION_PACK_RECORD);
 
-  if (table->getShare()->getPrimaryKey() >= MAX_KEY)
+  if (getTable()->getShare()->getPrimaryKey() >= MAX_KEY)
     share_ptr->primary_key_exists = false;
   else
     share_ptr->primary_key_exists = true;
@@ -1408,7 +1408,7 @@
       share->btrees[i].close();
     }
 
-    BlitzEngine *bz_engine = (BlitzEngine *)engine;
+    BlitzEngine *bz_engine = (BlitzEngine *)getEngine();
     bz_engine->deleteTableShare(share->table_name);
 
     delete[] share->btrees;

=== modified file 'plugin/blitzdb/ha_blitz.h'
--- plugin/blitzdb/ha_blitz.h	2010-07-08 10:20:38 +0000
+++ plugin/blitzdb/ha_blitz.h	2010-10-23 00:16:13 +0000
@@ -301,7 +301,7 @@
 
 public:
   ha_blitz(drizzled::plugin::StorageEngine &engine_arg,
-           drizzled::TableShare &table_arg);
+           drizzled::Table &table_arg);
   ~ha_blitz() {}
 
   /* TABLE CONTROL RELATED FUNCTIONS */

=== modified file 'plugin/csv/ha_tina.cc'
--- plugin/csv/ha_tina.cc	2010-10-10 08:28:30 +0000
+++ plugin/csv/ha_tina.cc	2010-10-23 00:16:13 +0000
@@ -112,7 +112,7 @@
     pthread_mutex_destroy(&tina_mutex);
   }
 
-  virtual Cursor *create(TableShare &table)
+  virtual Cursor *create(Table &table)
   {
     return new ha_tina(*this, table);
   }
@@ -279,7 +279,7 @@
 {
   pthread_mutex_lock(&tina_mutex);
 
-  Tina *a_tina= static_cast<Tina *>(engine);
+  Tina *a_tina= static_cast<Tina *>(getEngine());
   share= a_tina->findOpenTable(table_name);
 
   std::string meta_file_name;
@@ -481,7 +481,7 @@
       share->tina_write_opened= false;
     }
 
-    Tina *a_tina= static_cast<Tina *>(engine);
+    Tina *a_tina= static_cast<Tina *>(getEngine());
     a_tina->deleteOpenTable(share->table_name);
     delete share;
   }
@@ -530,7 +530,7 @@
 
 
 
-ha_tina::ha_tina(drizzled::plugin::StorageEngine &engine_arg, TableShare &table_arg)
+ha_tina::ha_tina(drizzled::plugin::StorageEngine &engine_arg, Table &table_arg)
   :Cursor(engine_arg, table_arg),
   /*
     These definitions are found in Cursor.h
@@ -557,7 +557,7 @@
 
   buffer.length(0);
 
-  for (Field **field= table->getFields() ; *field ; field++)
+  for (Field **field= getTable()->getFields() ; *field ; field++)
   {
     const char *ptr;
     const char *end_ptr;
@@ -675,9 +675,9 @@
 
   error= HA_ERR_CRASHED_ON_USAGE;
 
-  memset(buf, 0, table->getShare()->null_bytes);
+  memset(buf, 0, getTable()->getShare()->null_bytes);
 
-  for (Field **field=table->getFields() ; *field ; field++)
+  for (Field **field= getTable()->getFields() ; *field ; field++)
   {
     char curr_char;
 

=== modified file 'plugin/csv/ha_tina.h'
--- plugin/csv/ha_tina.h	2010-10-02 21:15:42 +0000
+++ plugin/csv/ha_tina.h	2010-10-23 00:16:13 +0000
@@ -88,7 +88,7 @@
   int init_data_file();
 
 public:
-  ha_tina(drizzled::plugin::StorageEngine &engine, drizzled::TableShare &table_arg);
+  ha_tina(drizzled::plugin::StorageEngine &engine, drizzled::Table &table_arg);
   ~ha_tina()
   {
     if (file_buff)

=== modified file 'plugin/filesystem_engine/filesystem_engine.cc'
--- plugin/filesystem_engine/filesystem_engine.cc	2010-09-25 22:17:18 +0000
+++ plugin/filesystem_engine/filesystem_engine.cc	2010-10-23 00:16:13 +0000
@@ -74,7 +74,7 @@
     pthread_mutex_destroy(&filesystem_mutex);
   }
 
-  virtual Cursor *create(TableShare &table)
+  virtual Cursor *create(Table &table)
   {
     return new FilesystemCursor(*this, table);
   }
@@ -369,7 +369,7 @@
 {
   Guard g(filesystem_mutex);
 
-  FilesystemEngine *a_engine= static_cast<FilesystemEngine *>(engine);
+  FilesystemEngine *a_engine= static_cast<FilesystemEngine *>(getEngine());
   share= a_engine->findOpenTable(table_name);
 
   /*
@@ -384,7 +384,7 @@
       return NULL;
     }
 
-    share->format.parseFromTable(table->getShare()->getTableProto());
+    share->format.parseFromTable(getTable()->getShare()->getTableProto());
     if (!share->format.isFileGiven())
     {
       return NULL;
@@ -414,7 +414,7 @@
   Guard g(filesystem_mutex);
 
   if (!--share->use_count){
-    FilesystemEngine *a_engine= static_cast<FilesystemEngine *>(engine);
+    FilesystemEngine *a_engine= static_cast<FilesystemEngine *>(getEngine());
     a_engine->deleteOpenTable(share->table_name);
     pthread_mutex_destroy(&share->mutex);
     delete share;
@@ -453,7 +453,7 @@
   thread_locked = false;
 }
 
-FilesystemCursor::FilesystemCursor(drizzled::plugin::StorageEngine &engine_arg, TableShare &table_arg)
+FilesystemCursor::FilesystemCursor(drizzled::plugin::StorageEngine &engine_arg, Table &table_arg)
   : Cursor(engine_arg, table_arg),
     file_buff(new TransparentFile),
     thread_locked(false)
@@ -487,7 +487,7 @@
 
 int FilesystemCursor::doStartTableScan(bool)
 {
-  sql_command_type = session_sql_command(table->getSession());
+  sql_command_type = session_sql_command(getTable()->getSession());
 
   if (thread_locked)
     critical_section_exit();
@@ -515,14 +515,14 @@
 
 int FilesystemCursor::find_current_row(unsigned char *buf)
 {
-  ptrdiff_t row_offset= buf - table->record[0];
+  ptrdiff_t row_offset= buf - getTable()->record[0];
 
   next_position= current_position;
 
   string content;
   bool line_done= false;
   bool line_blank= true;
-  Field **field= table->getFields();
+  Field **field= getTable()->getFields();
   for (; !line_done && *field; ++next_position)
   {
     char ch= file_buff->get_value(next_position);
@@ -616,8 +616,8 @@
     if (tag_depth >= share->vm.size())
       return HA_ERR_END_OF_FILE;
 
-    ptrdiff_t row_offset= buf - table->record[0];
-    for (Field **field= table->getFields(); *field; field++)
+    ptrdiff_t row_offset= buf - getTable()->record[0];
+    for (Field **field= getTable()->getFields(); *field; field++)
     {
       string key((*field)->field_name);
       string content= share->vm[tag_depth][key];
@@ -696,7 +696,7 @@
 
 int FilesystemCursor::doEndTableScan()
 {
-  sql_command_type = session_sql_command(table->getSession());
+  sql_command_type = session_sql_command(getTable()->getSession());
 
   if (share->format.isTagFormat())
   {
@@ -784,7 +784,7 @@
 {
   bool first= true;
   drizzled::String attribute;
-  for (Field **field= table->getFields(); *field; ++field)
+  for (Field **field= getTable()->getFields(); *field; ++field)
   {
     if (first == true)
     {
@@ -817,7 +817,7 @@
   if (share->format.isTagFormat())
     return 0;
 
-  sql_command_type = session_sql_command(table->getSession());
+  sql_command_type = session_sql_command(getTable()->getSession());
 
   critical_section_enter();
 

=== modified file 'plugin/filesystem_engine/filesystem_engine.h'
--- plugin/filesystem_engine/filesystem_engine.h	2010-07-30 12:39:39 +0000
+++ plugin/filesystem_engine/filesystem_engine.h	2010-10-23 00:16:13 +0000
@@ -67,7 +67,7 @@
   std::vector< std::pair<off_t, off_t> > slots;
 
 public:
-  FilesystemCursor(drizzled::plugin::StorageEngine &engine, drizzled::TableShare &table_arg);
+  FilesystemCursor(drizzled::plugin::StorageEngine &engine, drizzled::Table &table_arg);
   ~FilesystemCursor()
   {
   }

=== modified file 'plugin/function_engine/cursor.cc'
--- plugin/function_engine/cursor.cc	2010-07-29 00:35:25 +0000
+++ plugin/function_engine/cursor.cc	2010-10-23 00:16:13 +0000
@@ -37,7 +37,7 @@
 *****************************************************************************/
 
 FunctionCursor::FunctionCursor(plugin::StorageEngine &engine_arg,
-                               TableShare &table_arg) :
+                               Table &table_arg) :
   Cursor(engine_arg, table_arg),
   estimate_of_rows(100), // Completely fabricated, I used to use the value 2.
   rows_returned(0)
@@ -45,7 +45,7 @@
 
 int FunctionCursor::open(const char *name, int, uint32_t)
 {
-  tool= static_cast<Function *>(engine)->getFunction(name); 
+  tool= static_cast<Function *>(getEngine())->getFunction(name); 
 //  assert(tool);
 
   record_id= 0;
@@ -67,7 +67,7 @@
 int FunctionCursor::doStartTableScan(bool)
 {
   rows_returned= 0;
-  generator= tool->generator(table->getFields());
+  generator= tool->generator(getTable()->getFields());
 
   return 0;
 }
@@ -79,12 +79,12 @@
   ha_statistic_increment(&system_status_var::ha_read_rnd_next_count);
 
   /* Fix bug in the debug logic for field */
-  for (Field **field= table->getFields() ; *field ; field++)
+  for (Field **field= getTable()->getFields() ; *field ; field++)
   {
     (*field)->setWriteSet();
   }
 
-  more_rows= generator->sub_populate(table->getShare()->sizeFields());
+  more_rows= generator->sub_populate(getTable()->getShare()->sizeFields());
 
   if (more_rows)
   {
@@ -102,11 +102,11 @@
 
 void FunctionCursor::position(const unsigned char *record)
 {
-  if (row_cache.size() <= record_id * table->getShare()->getRecordLength())
+  if (row_cache.size() <= record_id * getTable()->getShare()->getRecordLength())
   {
-    row_cache.resize(row_cache.size() + table->getShare()->getRecordLength() * 100); // Hardwired at adding an additional 100 rows of storage
+    row_cache.resize(row_cache.size() + getTable()->getShare()->getRecordLength() * 100); // Hardwired at adding an additional 100 rows of storage
   }
-  memcpy(&row_cache[record_id * table->getShare()->getRecordLength()], record, table->getShare()->getRecordLength());
+  memcpy(&row_cache[record_id * getTable()->getShare()->getRecordLength()], record, getTable()->getShare()->getRecordLength());
   internal::my_store_ptr(ref, ref_length, record_id);
   record_id++;
 }
@@ -151,8 +151,8 @@
   ha_statistic_increment(&system_status_var::ha_read_rnd_count);
   size_t position_id= (size_t)internal::my_get_ptr(pos, ref_length);
 
-  assert(position_id * table->getShare()->getRecordLength() < row_cache.size());
-  memcpy(buf, &row_cache[position_id * table->getShare()->getRecordLength()], table->getShare()->getRecordLength());
+  assert(position_id * getTable()->getShare()->getRecordLength() < row_cache.size());
+  memcpy(buf, &row_cache[position_id * getTable()->getShare()->getRecordLength()], getTable()->getShare()->getRecordLength());
 
   return 0;
 }

=== modified file 'plugin/function_engine/cursor.h'
--- plugin/function_engine/cursor.h	2010-05-20 17:33:40 +0000
+++ plugin/function_engine/cursor.h	2010-10-23 00:16:13 +0000
@@ -39,7 +39,7 @@
 
 public:
   FunctionCursor(drizzled::plugin::StorageEngine &engine,
-                 drizzled::TableShare &table_arg);
+                 drizzled::Table &table_arg);
   ~FunctionCursor() {}
 
   int open(const char *name, int mode, uint32_t test_if_locked);

=== modified file 'plugin/function_engine/function.cc'
--- plugin/function_engine/function.cc	2010-10-10 11:41:42 +0000
+++ plugin/function_engine/function.cc	2010-10-23 00:16:13 +0000
@@ -49,7 +49,7 @@
 }
 
 
-Cursor *Function::create(TableShare &table)
+Cursor *Function::create(Table &table)
 {
   return new FunctionCursor(*this, table);
 }

=== modified file 'plugin/function_engine/function.h'
--- plugin/function_engine/function.h	2010-10-09 01:10:07 +0000
+++ plugin/function_engine/function.h	2010-10-23 00:16:13 +0000
@@ -59,7 +59,7 @@
     return EPERM; 
   }
 
-  virtual drizzled::Cursor *create(drizzled::TableShare &table);
+  virtual drizzled::Cursor *create(drizzled::Table &table);
 
   const char **bas_ext() const 
   {

=== modified file 'plugin/haildb/haildb_engine.cc'
--- plugin/haildb/haildb_engine.cc	2010-10-12 14:11:44 +0000
+++ plugin/haildb/haildb_engine.cc	2010-10-23 00:16:13 +0000
@@ -150,7 +150,7 @@
 
   ~HailDBEngine();
 
-  virtual Cursor *create(TableShare &table)
+  virtual Cursor *create(Table &table)
   {
     return new HailDBCursor(*this, table);
   }
@@ -474,7 +474,7 @@
 {
   uint64_t nr;
   ib_err_t err;
-  ib_trx_t transaction= *get_trx(table->in_use);
+  ib_trx_t transaction= *get_trx(getTable()->in_use);
   ib_cursor_attach_trx(cursor, transaction);
   tuple= ib_clust_read_tuple_create(cursor);
   err= ib_cursor_last(cursor);
@@ -485,7 +485,7 @@
   else
   {
     assert (err == DB_SUCCESS);
-    err= ib_tuple_read_u64(tuple, table->getShare()->fields, &nr);
+    err= ib_tuple_read_u64(tuple, getTable()->getShare()->fields, &nr);
     nr++;
   }
   ib_tuple_delete(tuple);
@@ -500,33 +500,33 @@
   int error;
 
   (void) extra(HA_EXTRA_KEYREAD);
-  table->mark_columns_used_by_index_no_reset(table->getShare()->next_number_index);
-  doStartIndexScan(table->getShare()->next_number_index, 1);
-  if (table->getShare()->next_number_keypart == 0)
+  getTable()->mark_columns_used_by_index_no_reset(getTable()->getShare()->next_number_index);
+  doStartIndexScan(getTable()->getShare()->next_number_index, 1);
+  if (getTable()->getShare()->next_number_keypart == 0)
   {						// Autoincrement at key-start
-    error=index_last(table->getUpdateRecord());
+    error=index_last(getTable()->getUpdateRecord());
   }
   else
   {
     unsigned char key[MAX_KEY_LENGTH];
-    key_copy(key, table->getInsertRecord(),
-             table->key_info + table->getShare()->next_number_index,
-             table->getShare()->next_number_key_offset);
-    error= index_read_map(table->getUpdateRecord(), key,
-                          make_prev_keypart_map(table->getShare()->next_number_keypart),
+    key_copy(key, getTable()->getInsertRecord(),
+             getTable()->key_info + getTable()->getShare()->next_number_index,
+             getTable()->getShare()->next_number_key_offset);
+    error= index_read_map(getTable()->getUpdateRecord(), key,
+                          make_prev_keypart_map(getTable()->getShare()->next_number_keypart),
                           HA_READ_PREFIX_LAST);
   }
 
   if (error)
     nr=1;
   else
-    nr= ((uint64_t) table->found_next_number_field->
-         val_int_offset(table->getShare()->rec_buff_length)+1);
+    nr= ((uint64_t) getTable()->found_next_number_field->
+         val_int_offset(getTable()->getShare()->rec_buff_length)+1);
   doEndIndexScan();
   (void) extra(HA_EXTRA_NO_KEYREAD);
 
-  if (table->getShare()->getTableProto()->options().auto_increment_value() > nr)
-    nr= table->getShare()->getTableProto()->options().auto_increment_value();
+  if (getTable()->getShare()->getTableProto()->options().auto_increment_value() > nr)
+    nr= getTable()->getShare()->getTableProto()->options().auto_increment_value();
 
   return nr;
 }
@@ -559,7 +559,7 @@
 {
   pthread_mutex_lock(&haildb_mutex);
 
-  HailDBEngine *a_engine= static_cast<HailDBEngine *>(engine);
+  HailDBEngine *a_engine= static_cast<HailDBEngine *>(getEngine());
   share= a_engine->findOpenTable(table_name);
 
   if (!share)
@@ -573,7 +573,7 @@
       return(NULL);
     }
 
-    if (table->found_next_number_field)
+    if (getTable()->found_next_number_field)
     {
       share->auto_increment_value.fetch_and_store(
                                   a_engine->getInitialAutoIncrementValue(this));
@@ -602,7 +602,7 @@
   pthread_mutex_lock(&haildb_mutex);
   if (!--share->use_count)
   {
-    HailDBEngine *a_engine= static_cast<HailDBEngine *>(engine);
+    HailDBEngine *a_engine= static_cast<HailDBEngine *>(getEngine());
     a_engine->deleteOpenTable(share->table_name);
     delete share;
   }
@@ -796,7 +796,7 @@
 }
 
 HailDBCursor::HailDBCursor(drizzled::plugin::StorageEngine &engine_arg,
-                           TableShare &table_arg)
+                           Table &table_arg)
   :Cursor(engine_arg, table_arg),
    ib_lock_mode(IB_LOCK_NONE),
    write_can_replace(false),
@@ -836,14 +836,14 @@
   lock.init(&share->lock);
 
 
-  if (table->getShare()->getPrimaryKey() != MAX_KEY)
-    ref_length= table->key_info[table->getShare()->getPrimaryKey()].key_length;
+  if (getTable()->getShare()->getPrimaryKey() != MAX_KEY)
+    ref_length= getTable()->key_info[getTable()->getShare()->getPrimaryKey()].key_length;
   else if (share->has_hidden_primary_key)
     ref_length= sizeof(uint64_t);
   else
   {
-    unsigned int keynr= get_first_unique_index(*table);
-    ref_length= table->key_info[keynr].key_length;
+    unsigned int keynr= get_first_unique_index(*getTable());
+    ref_length= getTable()->key_info[keynr].key_length;
   }
 
   in_table_scan= false;
@@ -1872,7 +1872,7 @@
   ib_err_t err;
   int ret= 0;
 
-  ib_trx_t transaction= *get_trx(table->in_use);
+  ib_trx_t transaction= *get_trx(getTable()->in_use);
 
   tuple= ib_clust_read_tuple_create(cursor);
 
@@ -1894,11 +1894,11 @@
      * yuck.
      */
 
-    HailDBEngine *storage_engine= static_cast<HailDBEngine*>(engine);
+    HailDBEngine *storage_engine= static_cast<HailDBEngine*>(getEngine());
     err= ib_cursor_reset(cursor);
     storage_engine->doCommit(current_session, true);
     storage_engine->doStartTransaction(current_session, START_TRANS_NO_OPTIONS);
-    transaction= *get_trx(table->in_use);
+    transaction= *get_trx(getTable()->in_use);
     assert(err == DB_SUCCESS);
     ib_cursor_attach_trx(cursor, transaction);
     err= ib_cursor_first(cursor);
@@ -1907,13 +1907,13 @@
   assert(err == DB_SUCCESS || err == DB_END_OF_INDEX);
 
 
-  if (table->next_number_field)
+  if (getTable()->next_number_field)
   {
     update_auto_increment();
 
-    uint64_t temp_auto= table->next_number_field->val_int();
+    uint64_t temp_auto= getTable()->next_number_field->val_int();
 
-    if (temp_auto <= innobase_get_int_col_max_value(table->next_number_field))
+    if (temp_auto <= innobase_get_int_col_max_value(getTable()->next_number_field))
     {
       while (true)
       {
@@ -1935,11 +1935,11 @@
 
   }
 
-  write_row_to_haildb_tuple(table->getFields(), tuple);
+  write_row_to_haildb_tuple(getTable()->getFields(), tuple);
 
   if (share->has_hidden_primary_key)
   {
-    err= ib_tuple_write_u64(tuple, table->getShare()->fields, share->hidden_pkey_auto_increment_value.fetch_and_increment());
+    err= ib_tuple_write_u64(tuple, getTable()->getShare()->fields, share->hidden_pkey_auto_increment_value.fetch_and_increment());
   }
 
   err= ib_cursor_insert_row(cursor, tuple);
@@ -1948,13 +1948,13 @@
   {
     if (write_can_replace)
     {
-      store_key_value_from_haildb(table->key_info + table->getShare()->getPrimaryKey(),
+      store_key_value_from_haildb(getTable()->key_info + getTable()->getShare()->getPrimaryKey(),
                                   ref, ref_length, record);
 
       ib_tpl_t search_tuple= ib_clust_search_tuple_create(cursor);
 
       fill_ib_search_tpl_from_drizzle_key(search_tuple,
-                                          table->key_info + 0,
+                                          getTable()->key_info + 0,
                                           ref, ref_length);
 
       int res;
@@ -1968,7 +1968,7 @@
       err= ib_cursor_first(cursor);
       assert(err == DB_SUCCESS || err == DB_END_OF_INDEX);
 
-      write_row_to_haildb_tuple(table->getFields(), tuple);
+      write_row_to_haildb_tuple(getTable()->getFields(), tuple);
 
       err= ib_cursor_insert_row(cursor, tuple);
       assert(err==DB_SUCCESS); // probably be nice and process errors
@@ -1997,7 +1997,7 @@
   err= ib_tuple_copy(update_tuple, tuple);
   assert(err == DB_SUCCESS);
 
-  write_row_to_haildb_tuple(table->getFields(), update_tuple);
+  write_row_to_haildb_tuple(getTable()->getFields(), update_tuple);
 
   err= ib_cursor_update_row(cursor, tuple, update_tuple);
 
@@ -2031,7 +2031,7 @@
      so only support TRUNCATE and not DELETE FROM t;
      (this is what ha_haildb does)
   */
-  if (session_sql_command(table->in_use) != SQLCOM_TRUNCATE)
+  if (session_sql_command(getTable()->in_use) != SQLCOM_TRUNCATE)
     return HA_ERR_WRONG_COMMAND;
 
   ib_id_t id;
@@ -2046,7 +2046,7 @@
   {
     ib_err_t rollback_err= ib_trx_rollback(transaction);
 
-    push_warning_printf(table->in_use, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
+    push_warning_printf(getTable()->in_use, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
                         ER_CANT_DELETE_FILE,
                         _("Cannot Lock HailDB Data Dictionary. HailDB Error %d (%s)\n"),
                         err, ib_strerror(err));
@@ -2087,7 +2087,7 @@
     doEndTableScan();
   in_table_scan= true;
 
-  transaction= *get_trx(table->in_use);
+  transaction= *get_trx(getTable()->in_use);
 
   assert(transaction != NULL);
 
@@ -2206,7 +2206,7 @@
     err= ib_cursor_next(cursor);
 
   tuple= ib_tuple_clear(tuple);
-  ret= read_row_from_haildb(buf, cursor, tuple, table,
+  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
                             share->has_hidden_primary_key,
                             &hidden_autoinc_pkey_position);
 
@@ -2241,13 +2241,13 @@
   else
   {
     unsigned int keynr;
-    if (table->getShare()->getPrimaryKey() != MAX_KEY)
-      keynr= table->getShare()->getPrimaryKey();
+    if (getTable()->getShare()->getPrimaryKey() != MAX_KEY)
+      keynr= getTable()->getShare()->getPrimaryKey();
     else
-      keynr= get_first_unique_index(*table);
+      keynr= get_first_unique_index(*getTable());
 
     fill_ib_search_tpl_from_drizzle_key(search_tuple,
-                                        table->key_info + keynr,
+                                        getTable()->key_info + keynr,
                                         pos, ref_length);
   }
 
@@ -2263,7 +2263,7 @@
   tuple= ib_tuple_clear(tuple);
 
   if (ret == 0)
-    ret= read_row_from_haildb(buf, cursor, tuple, table,
+    ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
                               share->has_hidden_primary_key,
                               &hidden_autoinc_pkey_position);
 
@@ -2334,12 +2334,12 @@
   else
   {
     unsigned int keynr;
-    if (table->getShare()->getPrimaryKey() != MAX_KEY)
-      keynr= table->getShare()->getPrimaryKey();
+    if (getTable()->getShare()->getPrimaryKey() != MAX_KEY)
+      keynr= getTable()->getShare()->getPrimaryKey();
     else
-      keynr= get_first_unique_index(*table);
+      keynr= get_first_unique_index(*getTable());
 
-    store_key_value_from_haildb(table->key_info + keynr,
+    store_key_value_from_haildb(getTable()->key_info + keynr,
                                 ref, ref_length, record);
   }
 
@@ -2385,7 +2385,7 @@
 
 int HailDBCursor::doStartIndexScan(uint32_t keynr, bool)
 {
-  ib_trx_t transaction= *get_trx(table->in_use);
+  ib_trx_t transaction= *get_trx(getTable()->in_use);
 
   active_index= keynr;
 
@@ -2399,8 +2399,8 @@
   {
     ib_err_t err;
     ib_id_t index_id;
-    err= ib_index_get_id(table_path_to_haildb_name(table_share->getPath()),
-                         table_share->getKeyInfo(keynr).name,
+    err= ib_index_get_id(table_path_to_haildb_name(getShare()->getPath()),
+                         getShare()->getKeyInfo(keynr).name,
                          &index_id);
     if (err != DB_SUCCESS)
       return -1;
@@ -2547,7 +2547,7 @@
     search_tuple= ib_sec_search_tuple_create(cursor);
 
   fill_ib_search_tpl_from_drizzle_key(search_tuple,
-                                      table->key_info + active_index,
+                                      getTable()->key_info + active_index,
                                       key_ptr, key_len);
 
   err= ib_cursor_moveto(cursor, search_tuple, search_mode, &res);
@@ -2555,7 +2555,7 @@
 
   if ((err == DB_RECORD_NOT_FOUND || err == DB_END_OF_INDEX))
   {
-    table->status= STATUS_NOT_FOUND;
+    getTable()->status= STATUS_NOT_FOUND;
     return HA_ERR_KEY_NOT_FOUND;
   }
 
@@ -2565,14 +2565,14 @@
   }
 
   tuple= ib_tuple_clear(tuple);
-  ret= read_row_from_haildb(buf, cursor, tuple, table,
+  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
                             share->has_hidden_primary_key,
                             &hidden_autoinc_pkey_position,
                             (allocate_blobs)? &blobroot : NULL);
   if (ret == 0)
-    table->status= 0;
+    getTable()->status= 0;
   else
-    table->status= STATUS_NOT_FOUND;
+    getTable()->status= STATUS_NOT_FOUND;
 
   advance_cursor= true;
 
@@ -2594,8 +2594,8 @@
   /* works only with key prefixes */
   assert(((keypart_map_arg + 1) & keypart_map_arg) == 0);
 
-  KeyPartInfo *key_part_found= table->getShare()->getKeyInfo(key_position).key_part;
-  KeyPartInfo *end_key_part_found= key_part_found + table->getShare()->getKeyInfo(key_position).key_parts;
+  KeyPartInfo *key_part_found= getTable()->getShare()->getKeyInfo(key_position).key_part;
+  KeyPartInfo *end_key_part_found= key_part_found + getTable()->getShare()->getKeyInfo(key_position).key_parts;
   uint32_t length= 0;
 
   while (key_part_found < end_key_part_found && keypart_map_arg)
@@ -2654,7 +2654,7 @@
   }
 
   tuple= ib_tuple_clear(tuple);
-  ret= read_row_from_haildb(buf, cursor, tuple, table,
+  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
                             share->has_hidden_primary_key,
                             &hidden_autoinc_pkey_position);
 
@@ -2687,7 +2687,7 @@
   }
 
   tuple= ib_tuple_clear(tuple);
-  ret= read_row_from_haildb(buf, cursor, tuple, table,
+  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
                             share->has_hidden_primary_key,
                             &hidden_autoinc_pkey_position);
 
@@ -2707,7 +2707,7 @@
     return ib_err_t_to_drizzle_error(err);
 
   tuple= ib_tuple_clear(tuple);
-  ret= read_row_from_haildb(buf, cursor, tuple, table,
+  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
                             share->has_hidden_primary_key,
                             &hidden_autoinc_pkey_position);
 
@@ -2727,7 +2727,7 @@
     return ib_err_t_to_drizzle_error(err);
 
   tuple= ib_tuple_clear(tuple);
-  ret= read_row_from_haildb(buf, cursor, tuple, table,
+  ret= read_row_from_haildb(buf, cursor, tuple, getTable(),
                             share->has_hidden_primary_key,
                             &hidden_autoinc_pkey_position);
   advance_cursor= true;

=== modified file 'plugin/haildb/haildb_engine.h'
--- plugin/haildb/haildb_engine.h	2010-09-30 05:47:49 +0000
+++ plugin/haildb/haildb_engine.h	2010-10-23 00:16:13 +0000
@@ -39,7 +39,7 @@
 class HailDBCursor: public drizzled::Cursor
 {
 public:
-  HailDBCursor(drizzled::plugin::StorageEngine &engine, drizzled::TableShare &table_arg);
+  HailDBCursor(drizzled::plugin::StorageEngine &engine, drizzled::Table &table_arg);
   ~HailDBCursor()
   {}
 

=== modified file 'plugin/innobase/handler/ha_innodb.cc'
--- plugin/innobase/handler/ha_innodb.cc	2010-10-14 12:36:24 +0000
+++ plugin/innobase/handler/ha_innodb.cc	2010-10-23 00:16:13 +0000
@@ -391,7 +391,7 @@
         /* out: 0 or error number */
     ::drizzled::XID *xid);  /* in: X/Open XA transaction identification */
 
-  virtual Cursor *create(TableShare &table)
+  virtual Cursor *create(Table &table)
   {
     return new ha_innobase(*this, table);
   }
@@ -1612,7 +1612,7 @@
 Construct ha_innobase Cursor. */
 UNIV_INTERN
 ha_innobase::ha_innobase(plugin::StorageEngine &engine_arg,
-                         TableShare &table_arg)
+                         Table &table_arg)
   :Cursor(engine_arg, table_arg),
   primary_key(0), /* needs initialization because index_flags() may be called 
                      before this is set to the real value. It's ok to have any 
@@ -2897,8 +2897,8 @@
   const char* col_name;
   ulint   error;
 
-  col_name = table->found_next_number_field->field_name;
-  index = innobase_get_index(table->getShare()->next_number_index);
+  col_name = getTable()->found_next_number_field->field_name;
+  index = innobase_get_index(getTable()->getShare()->next_number_index);
 
   /* Execute SELECT MAX(col_name) FROM TABLE; */
   error = row_search_max_autoinc(index, col_name, &auto_inc);
@@ -2956,7 +2956,7 @@
   UT_NOT_USED(mode);
   UT_NOT_USED(test_if_locked);
 
-  session= table->in_use;
+  session= getTable()->in_use;
 
   /* Under some cases Drizzle seems to call this function while
   holding btr_search_latch. This breaks the latching order as
@@ -2980,8 +2980,8 @@
   stored the string length as the first byte. */
 
   upd_and_key_val_buff_len =
-        table->getShare()->stored_rec_length
-        + table->getShare()->max_key_length
+        getTable()->getShare()->stored_rec_length
+        + getTable()->getShare()->max_key_length
         + MAX_REF_PARTS * 3;
 
   upd_buff.resize(upd_and_key_val_buff_len);
@@ -3044,13 +3044,13 @@
 
   prebuilt = row_create_prebuilt(ib_table);
 
-  prebuilt->mysql_row_len = table->getShare()->stored_rec_length;
-  prebuilt->default_rec = table->getDefaultValues();
+  prebuilt->mysql_row_len = getTable()->getShare()->stored_rec_length;
+  prebuilt->default_rec = getTable()->getDefaultValues();
   ut_ad(prebuilt->default_rec);
 
   /* Looks like MySQL-3.23 sometimes has primary key number != 0 */
 
-  primary_key = table->getShare()->getPrimaryKey();
+  primary_key = getTable()->getShare()->getPrimaryKey();
   key_used_on_scan = primary_key;
 
   /* Allocate a buffer for a 'row reference'. A row reference is
@@ -3073,7 +3073,7 @@
     save space, because all row reference buffers are allocated
     based on ref_length. */
 
-    ref_length = table->key_info[primary_key].key_length;
+    ref_length = getTable()->key_info[primary_key].key_length;
   } else {
     if (primary_key != MAX_KEY) {
       errmsg_printf(ERRMSG_LVL_ERROR, "Table %s has no primary key in InnoDB data "
@@ -3125,7 +3125,7 @@
   info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
 
   /* Only if the table has an AUTOINC column. */
-  if (prebuilt->table != NULL && table->found_next_number_field != NULL) {
+  if (prebuilt->table != NULL && getTable()->found_next_number_field != NULL) {
     ulint error;
 
     dict_table_autoinc_lock(prebuilt->table);
@@ -3163,7 +3163,7 @@
 {
   Session*  session;
 
-  session= table->in_use;
+  session= getTable()->in_use;
   if (session != NULL) {
     getTransactionalEngine()->releaseTemporaryLatches(session);
   }
@@ -3444,7 +3444,7 @@
   uint    buff_len,/*!< in: buffer length */
   const unsigned char*  record)/*!< in: row in MySQL format */
 {
-  KeyInfo*    key_info  = &table->key_info[keynr];
+  KeyInfo*    key_info  = &getTable()->key_info[keynr];
   KeyPartInfo*  key_part  = key_info->key_part;
   KeyPartInfo*  end   = key_part + key_info->key_parts;
   char*   buff_start  = buff;
@@ -3520,7 +3520,7 @@
 
       data = row_mysql_read_true_varchar(&len,
         (byte*) (record
-        + (ulint)get_field_offset(table, field)),
+        + (ulint)get_field_offset(getTable(), field)),
         lenlen);
 
       true_len = len;
@@ -3583,12 +3583,12 @@
 
       blob_data = row_mysql_read_blob_ref(&blob_len,
         (byte*) (record
-        + (ulint)get_field_offset(table, field)),
+        + (ulint)get_field_offset(getTable(), field)),
           (ulint) field->pack_length());
 
       true_len = blob_len;
 
-      ut_a(get_field_offset(table, field)
+      ut_a(get_field_offset(getTable(), field)
         == key_part->offset);
 
       /* For multi byte character sets we need to calculate
@@ -4079,7 +4079,7 @@
   num_write_row++;
 
   /* This is the case where the table has an auto-increment column */
-  if (table->next_number_field && record == table->getInsertRecord()) {
+  if (getTable()->next_number_field && record == getTable()->getInsertRecord()) {
 
     /* Reset the error code before calling
     innobase_get_auto_increment(). */
@@ -4108,8 +4108,7 @@
     /* Build the template used in converting quickly between
     the two database formats */
 
-    build_template(prebuilt, NULL, table,
-             ROW_MYSQL_WHOLE_ROW);
+    build_template(prebuilt, NULL, getTable(), ROW_MYSQL_WHOLE_ROW);
   }
 
   innodb_srv_conc_enter_innodb(prebuilt->trx);
@@ -4133,10 +4132,9 @@
     /* We need the upper limit of the col type to check for
     whether we update the table autoinc counter or not. */
     col_max_value = innobase_get_int_col_max_value(
-      table->next_number_field);
-
+      getTable()->next_number_field); 
     /* Get the value that MySQL attempted to store in the table.*/
-    auto_inc = table->next_number_field->val_int();
+    auto_inc = getTable()->next_number_field->val_int();
 
     switch (error) {
     case DB_DUPLICATE_KEY:
@@ -4386,7 +4384,7 @@
   /* Build an update vector from the modified fields in the rows
   (uses upd_buff of the handle) */
 
-  calc_row_difference(uvect, (unsigned char*) old_row, new_row, table,
+  calc_row_difference(uvect, (unsigned char*) old_row, new_row, getTable(),
       &upd_buff[0], (ulint)upd_and_key_val_buff_len,
       prebuilt, user_session);
 
@@ -4395,17 +4393,17 @@
 
   ut_a(prebuilt->template_type == ROW_MYSQL_WHOLE_ROW);
 
-  if (table->found_next_number_field)
+  if (getTable()->found_next_number_field)
   {
     uint64_t  auto_inc;
     uint64_t  col_max_value;
 
-    auto_inc = table->found_next_number_field->val_int();
+    auto_inc = getTable()->found_next_number_field->val_int();
 
     /* We need the upper limit of the col type to check for
     whether we update the table autoinc counter or not. */
     col_max_value = innobase_get_int_col_max_value(
-      table->found_next_number_field);
+      getTable()->found_next_number_field);
 
     uint64_t current_autoinc;
     ulint autoinc_error= innobase_get_autoinc(&current_autoinc);
@@ -4442,8 +4440,8 @@
   value used in the INSERT statement.*/
 
   if (error == DB_SUCCESS
-      && table->next_number_field
-      && new_row == table->getInsertRecord()
+      && getTable()->next_number_field
+      && new_row == getTable()->getInsertRecord()
       && session_sql_command(user_session) == SQLCOM_INSERT
       && (trx->duplicates & (TRX_DUP_IGNORE | TRX_DUP_REPLACE))
     == TRX_DUP_IGNORE)  {
@@ -4451,12 +4449,12 @@
     uint64_t  auto_inc;
     uint64_t  col_max_value;
 
-    auto_inc = table->next_number_field->val_int();
+    auto_inc = getTable()->next_number_field->val_int();
 
     /* We need the upper limit of the col type to check for
     whether we update the table autoinc counter or not. */
     col_max_value = innobase_get_int_col_max_value(
-      table->next_number_field);
+      getTable()->next_number_field);
 
     if (auto_inc <= col_max_value && auto_inc != 0) {
 
@@ -4586,7 +4584,7 @@
 ha_innobase::try_semi_consistent_read(bool yes)
 /*===========================================*/
 {
-  ut_a(prebuilt->trx == session_to_trx(table->in_use));
+  ut_a(prebuilt->trx == session_to_trx(getTable()->in_use));
 
   /* Row read type is set to semi consistent read if this was
   requested by the MySQL and either innodb_locks_unsafe_for_binlog
@@ -4786,7 +4784,7 @@
   necessarily prebuilt->index, but can also be the clustered index */
 
   if (prebuilt->sql_stat_start) {
-    build_template(prebuilt, user_session, table,
+    build_template(prebuilt, user_session, getTable(),
              ROW_MYSQL_REC_FIELDS);
   }
 
@@ -4841,21 +4839,21 @@
   switch (ret) {
   case DB_SUCCESS:
     error = 0;
-    table->status = 0;
+    getTable()->status = 0;
     break;
   case DB_RECORD_NOT_FOUND:
     error = HA_ERR_KEY_NOT_FOUND;
-    table->status = STATUS_NOT_FOUND;
+    getTable()->status = STATUS_NOT_FOUND;
     break;
   case DB_END_OF_INDEX:
     error = HA_ERR_KEY_NOT_FOUND;
-    table->status = STATUS_NOT_FOUND;
+    getTable()->status = STATUS_NOT_FOUND;
     break;
   default:
     error = convert_error_code_to_mysql((int) ret,
                 prebuilt->table->flags,
                 user_session);
-    table->status = STATUS_NOT_FOUND;
+    getTable()->status = STATUS_NOT_FOUND;
     break;
   }
 
@@ -4897,10 +4895,10 @@
   ut_ad(user_session == table->in_use);
   ut_a(prebuilt->trx == session_to_trx(user_session));
 
-  if (keynr != MAX_KEY && table->getShare()->sizeKeys() > 0) 
+  if (keynr != MAX_KEY && getTable()->getShare()->sizeKeys() > 0) 
   {
     index = dict_table_get_index_on_name(prebuilt->table,
-                                         table->getShare()->getTableProto()->indexes(keynr).name().c_str());
+                                         getTable()->getShare()->getTableProto()->indexes(keynr).name().c_str());
   } else {
     index = dict_table_get_first_index(prebuilt->table);
   }
@@ -4909,7 +4907,7 @@
     errmsg_printf(ERRMSG_LVL_ERROR, 
       "Innodb could not find key n:o %u with name %s "
       "from dict cache for table %s",
-      keynr, table->getShare()->getTableProto()->indexes(keynr).name().c_str(),
+      keynr, getTable()->getShare()->getTableProto()->indexes(keynr).name().c_str(),
       prebuilt->table->name);
   }
 
@@ -4967,7 +4965,7 @@
   the flag ROW_MYSQL_WHOLE_ROW below, but that caused unnecessary
   copying. Starting from MySQL-4.1 we use a more efficient flag here. */
 
-  build_template(prebuilt, user_session, table, ROW_MYSQL_REC_FIELDS);
+  build_template(prebuilt, user_session, getTable(), ROW_MYSQL_REC_FIELDS);
 
   return(0);
 }
@@ -5027,20 +5025,20 @@
   switch (ret) {
   case DB_SUCCESS:
     error = 0;
-    table->status = 0;
+    getTable()->status = 0;
     break;
   case DB_RECORD_NOT_FOUND:
     error = HA_ERR_END_OF_FILE;
-    table->status = STATUS_NOT_FOUND;
+    getTable()->status = STATUS_NOT_FOUND;
     break;
   case DB_END_OF_INDEX:
     error = HA_ERR_END_OF_FILE;
-    table->status = STATUS_NOT_FOUND;
+    getTable()->status = STATUS_NOT_FOUND;
     break;
   default:
     error = convert_error_code_to_mysql(
       (int) ret, prebuilt->table->flags, user_session);
-    table->status = STATUS_NOT_FOUND;
+    getTable()->status = STATUS_NOT_FOUND;
     break;
   }
 
@@ -5235,7 +5233,7 @@
 
   ha_statistic_increment(&system_status_var::ha_read_rnd_count);
 
-  ut_a(prebuilt->trx == session_to_trx(table->in_use));
+  ut_a(prebuilt->trx == session_to_trx(getTable()->in_use));
 
   if (prebuilt->clust_index_was_generated) {
     /* No primary key was defined for the table and we
@@ -5281,7 +5279,7 @@
 {
   uint    len;
 
-  ut_a(prebuilt->trx == session_to_trx(table->in_use));
+  ut_a(prebuilt->trx == session_to_trx(getTable()->in_use));
 
   if (prebuilt->clust_index_was_generated) {
     /* No primary key was defined for the table and we
@@ -5950,7 +5948,7 @@
 
   ut_a(prebuilt->trx);
   ut_a(prebuilt->trx->magic_n == TRX_MAGIC_N);
-  ut_a(prebuilt->trx == session_to_trx(table->in_use));
+  ut_a(prebuilt->trx == session_to_trx(getTable()->in_use));
 
   dict_table = prebuilt->table;
   trx = prebuilt->trx;
@@ -5979,7 +5977,7 @@
   /* Get the transaction associated with the current session, or create one
   if not yet created, and update prebuilt->trx */
 
-  update_session(table->in_use);
+  update_session(getTable()->in_use);
 
   if (session_sql_command(user_session) != SQLCOM_TRUNCATE) {
   fallback:
@@ -6321,10 +6319,10 @@
   KeyInfo*    key;
   dict_index_t* index;
   unsigned char*    key_val_buff2 = (unsigned char*) malloc(
-              table->getShare()->stored_rec_length
-          + table->getShare()->max_key_length + 100);
-  ulint   buff2_len = table->getShare()->stored_rec_length
-          + table->getShare()->max_key_length + 100;
+              getTable()->getShare()->stored_rec_length
+          + getTable()->getShare()->max_key_length + 100);
+  ulint   buff2_len = getTable()->getShare()->stored_rec_length
+          + getTable()->getShare()->max_key_length + 100;
   dtuple_t* range_start;
   dtuple_t* range_end;
   ib_int64_t  n_rows;
@@ -6332,7 +6330,7 @@
   ulint   mode2;
   mem_heap_t* heap;
 
-  ut_a(prebuilt->trx == session_to_trx(table->in_use));
+  ut_a(prebuilt->trx == session_to_trx(getTable()->in_use));
 
   prebuilt->trx->op_info = (char*)"estimating records in index range";
 
@@ -6343,9 +6341,9 @@
 
   active_index = keynr;
 
-  key = &table->key_info[active_index];
+  key = &getTable()->key_info[active_index];
 
-  index = dict_table_get_index_on_name(prebuilt->table, table->getShare()->getTableProto()->indexes(active_index).name().c_str());
+  index = dict_table_get_index_on_name(prebuilt->table, getTable()->getShare()->getTableProto()->indexes(active_index).name().c_str());
 
   /* MySQL knows about this index and so we must be able to find it.*/
   ut_a(index);
@@ -6427,7 +6425,7 @@
   external_lock(). To be safe, update the session of the current table
   handle. */
 
-  update_session(table->in_use);
+  update_session(getTable()->in_use);
 
   prebuilt->trx->op_info = (char*)
          "calculating upper bound for table rows";
@@ -6491,7 +6489,7 @@
   ha_rows total_rows;
   double  time_for_scan;
 
-  if (index != table->getShare()->getPrimaryKey()) {
+  if (index != getTable()->getShare()->getPrimaryKey()) {
     /* Not clustered */
     return(Cursor::read_time(index, ranges, rows));
   }
@@ -6549,7 +6547,7 @@
   external_lock(). To be safe, update the session of the current table
   handle. */
 
-  update_session(table->in_use);
+  update_session(getTable()->in_use);
 
   /* In case MySQL calls this in the middle of a SELECT query, release
   possible adaptive hash latch to avoid deadlocks of threads */
@@ -6657,7 +6655,7 @@
 
         Session*  session;
 
-        session= table->in_use;
+        session= getTable()->in_use;
         assert(session);
 
         push_warning_printf(
@@ -6693,7 +6691,7 @@
       index = dict_table_get_next_index(index);
     }
 
-    for (i = 0; i < table->getShare()->sizeKeys(); i++) {
+    for (i = 0; i < getTable()->getShare()->sizeKeys(); i++) {
       if (index == NULL) {
         errmsg_printf(ERRMSG_LVL_ERROR, "Table %s contains fewer "
             "indexes inside InnoDB than "
@@ -6707,7 +6705,7 @@
         break;
       }
 
-      for (j = 0; j < table->key_info[i].key_parts; j++) {
+      for (j = 0; j < getTable()->key_info[i].key_parts; j++) {
 
         if (j + 1 > index->n_uniq) {
           errmsg_printf(ERRMSG_LVL_ERROR, 
@@ -6741,7 +6739,7 @@
           rec_per_key = 1;
         }
 
-        table->key_info[i].rec_per_key[j]=
+        getTable()->key_info[i].rec_per_key[j]=
           rec_per_key >= ~(ulong) 0 ? ~(ulong) 0 :
           (ulong) rec_per_key;
       }
@@ -6766,7 +6764,7 @@
     }
   }
 
-  if ((flag & HA_STATUS_AUTO) && table->found_next_number_field) {
+  if ((flag & HA_STATUS_AUTO) && getTable()->found_next_number_field) {
     stats.auto_increment_value = innobase_peek_autoinc();
   }
 
@@ -6810,7 +6808,7 @@
 {
   ulint   ret;
 
-  assert(session == table->in_use);
+  assert(session == getTable()->in_use);
   ut_a(prebuilt->trx);
   ut_a(prebuilt->trx->magic_n == TRX_MAGIC_N);
   ut_a(prebuilt->trx == session_to_trx(session));
@@ -6819,7 +6817,7 @@
     /* Build the template; we will use a dummy template
     in index scans done in checking */
 
-    build_template(prebuilt, NULL, table, ROW_MYSQL_WHOLE_ROW);
+    build_template(prebuilt, NULL, getTable(), ROW_MYSQL_WHOLE_ROW);
   }
 
   ret = row_check_table_for_mysql(prebuilt);
@@ -6858,7 +6856,7 @@
     return((char*)comment); /* string too long */
   }
 
-  update_session(table->in_use);
+  update_session(getTable()->in_use);
 
   prebuilt->trx->op_info = (char*)"returning table comment";
 
@@ -6929,7 +6927,7 @@
   external_lock(). To be safe, update the session of the current table
   handle. */
 
-  update_session(table->in_use);
+  update_session(getTable()->in_use);
 
   prebuilt->trx->op_info = (char*)"getting info on foreign keys";
 
@@ -6978,7 +6976,7 @@
   dict_foreign_t* foreign;
 
   ut_a(prebuilt != NULL);
-  update_session(table->in_use);
+  update_session(getTable()->in_use);
   prebuilt->trx->op_info = (char*)"getting list of foreign keys";
   trx_search_latch_release_if_reserved(prebuilt->trx);
   mutex_enter(&(dict_sys->mutex));
@@ -7116,7 +7114,7 @@
 {
   bool  can_switch;
 
-  ut_a(prebuilt->trx == session_to_trx(table->in_use));
+  ut_a(prebuilt->trx == session_to_trx(getTable()->in_use));
 
   prebuilt->trx->op_info =
       "determining if there are foreign key constraints";
@@ -7204,16 +7202,16 @@
       either, because the calling threads may change.
       CAREFUL HERE, OR MEMORY CORRUPTION MAY OCCUR! */
     case HA_EXTRA_IGNORE_DUP_KEY:
-      session_to_trx(table->in_use)->duplicates |= TRX_DUP_IGNORE;
+      session_to_trx(getTable()->in_use)->duplicates |= TRX_DUP_IGNORE;
       break;
     case HA_EXTRA_WRITE_CAN_REPLACE:
-      session_to_trx(table->in_use)->duplicates |= TRX_DUP_REPLACE;
+      session_to_trx(getTable()->in_use)->duplicates |= TRX_DUP_REPLACE;
       break;
     case HA_EXTRA_WRITE_CANNOT_REPLACE:
-      session_to_trx(table->in_use)->duplicates &= ~TRX_DUP_REPLACE;
+      session_to_trx(getTable()->in_use)->duplicates &= ~TRX_DUP_REPLACE;
       break;
     case HA_EXTRA_NO_IGNORE_DUP_KEY:
-      session_to_trx(table->in_use)->duplicates &=
+      session_to_trx(getTable()->in_use)->duplicates &=
         ~(TRX_DUP_IGNORE | TRX_DUP_REPLACE);
       break;
     default:/* Do nothing */
@@ -7854,7 +7852,7 @@
   uint64_t  autoinc = 0;
 
   /* Prepare prebuilt->trx in the table handle */
-  update_session(table->in_use);
+  update_session(getTable()->in_use);
 
   error = innobase_get_autoinc(&autoinc);
 
@@ -7908,7 +7906,7 @@
     /* We need the upper limit of the col type to check for
     whether we update the table autoinc counter or not. */
     col_max_value = innobase_get_int_col_max_value(
-      table->next_number_field);
+      getTable()->next_number_field);
 
     current = *first_value > col_max_value ? autoinc : *first_value;
     need = *nb_reserved_values * increment;
@@ -7951,7 +7949,7 @@
 {
   int error;
 
-  update_session(table->in_use);
+  update_session(getTable()->in_use);
 
   error = row_lock_table_autoinc_for_mysql(prebuilt);
 
@@ -8017,10 +8015,10 @@
   /* Do a type-aware comparison of primary key fields. PK fields
   are always NOT NULL, so no checks for NULL are performed. */
 
-  key_part = table->key_info[table->getShare()->getPrimaryKey()].key_part;
+  key_part = getTable()->key_info[getTable()->getShare()->getPrimaryKey()].key_part;
 
   key_part_end = key_part
-      + table->key_info[table->getShare()->getPrimaryKey()].key_parts;
+      + getTable()->key_info[getTable()->getShare()->getPrimaryKey()].key_parts;
 
   for (; key_part != key_part_end; ++key_part) {
     field = key_part->field;

=== modified file 'plugin/innobase/handler/ha_innodb.h'
--- plugin/innobase/handler/ha_innodb.h	2010-10-12 05:42:04 +0000
+++ plugin/innobase/handler/ha_innodb.h	2010-10-23 00:16:13 +0000
@@ -107,7 +107,7 @@
 	/* Init values for the class: */
  public:
 	UNIV_INTERN ha_innobase(plugin::StorageEngine &engine,
-                                TableShare &table_arg);
+                                Table &table_arg);
 	UNIV_INTERN ~ha_innobase();
   /**
    * Returns the plugin::TransactionStorageEngine pointer
@@ -119,7 +119,7 @@
    */
   UNIV_INTERN plugin::TransactionalStorageEngine *getTransactionalEngine()
   {
-    return static_cast<plugin::TransactionalStorageEngine *>(engine);
+    return static_cast<plugin::TransactionalStorageEngine *>(getEngine());
   }
 
 	UNIV_INTERN const char* index_type(uint key_number);

=== modified file 'plugin/memory/ha_heap.cc'
--- plugin/memory/ha_heap.cc	2010-10-02 21:15:42 +0000
+++ plugin/memory/ha_heap.cc	2010-10-23 00:16:13 +0000
@@ -60,7 +60,7 @@
     hp_panic(HA_PANIC_CLOSE);
   }
 
-  virtual Cursor *create(TableShare &table)
+  virtual Cursor *create(Table &table)
   {
     return new ha_heap(*this, table);
   }
@@ -158,7 +158,7 @@
 *****************************************************************************/
 
 ha_heap::ha_heap(plugin::StorageEngine &engine_arg,
-                 TableShare &table_arg)
+                 Table &table_arg)
   :Cursor(engine_arg, table_arg), file(0), records_changed(0), key_stat_version(0),
   internal_table(0)
 {}
@@ -185,9 +185,9 @@
     HP_SHARE *internal_share= NULL;
     message::Table create_proto;
 
-    if (not heap_storage_engine->heap_create_table(table->in_use,
+    if (not heap_storage_engine->heap_create_table(getTable()->in_use,
                                                    identifier.getPath().c_str(),
-                                                   table,
+                                                   getTable(),
                                                    internal_table,
                                                    create_proto,
                                                    &internal_share))
@@ -240,12 +240,12 @@
 
 Cursor *ha_heap::clone(memory::Root *)
 {
-  Cursor *new_handler= table->getMutableShare()->db_type()->getCursor(*(table->getMutableShare()));
-  TableIdentifier identifier(table->getShare()->getSchemaName(),
-                             table->getShare()->getTableName(),
-                             table->getShare()->getPath());
+  Cursor *new_handler= getTable()->getMutableShare()->db_type()->getCursor(*getTable());
+  TableIdentifier identifier(getTable()->getShare()->getSchemaName(),
+                             getTable()->getShare()->getTableName(),
+                             getTable()->getShare()->getPath());
 
-  if (new_handler && !new_handler->ha_open(identifier, table, table->db_stat,
+  if (new_handler && !new_handler->ha_open(identifier, getTable()->db_stat,
                                            HA_OPEN_IGNORE_IF_LOCKED))
     return new_handler;
   return NULL;
@@ -281,9 +281,9 @@
 
 void ha_heap::update_key_stats()
 {
-  for (uint32_t i= 0; i < table->getShare()->sizeKeys(); i++)
+  for (uint32_t i= 0; i < getTable()->getShare()->sizeKeys(); i++)
   {
-    KeyInfo *key= &table->key_info[i];
+    KeyInfo *key= &getTable()->key_info[i];
 
     if (!key->rec_per_key)
       continue;
@@ -310,7 +310,7 @@
 int ha_heap::doInsertRecord(unsigned char * buf)
 {
   int res;
-  if (table->next_number_field && buf == table->getInsertRecord())
+  if (getTable()->next_number_field && buf == getTable()->getInsertRecord())
   {
     if ((res= update_auto_increment()))
       return res;
@@ -350,7 +350,7 @@
   int res;
 
   res= heap_delete(file,buf);
-  if (!res && table->getShare()->getType() == message::Table::STANDARD &&
+  if (!res && getTable()->getShare()->getType() == message::Table::STANDARD &&
       ++records_changed*MEMORY_STATS_UPDATE_THRESHOLD > file->getShare()->records)
   {
     /*
@@ -369,7 +369,7 @@
   assert(inited==INDEX);
   ha_statistic_increment(&system_status_var::ha_read_key_count);
   int error = heap_rkey(file,buf,active_index, key, keypart_map, find_flag);
-  table->status = error ? STATUS_NOT_FOUND : 0;
+  getTable()->status = error ? STATUS_NOT_FOUND : 0;
   return error;
 }
 
@@ -380,7 +380,7 @@
   ha_statistic_increment(&system_status_var::ha_read_key_count);
   int error= heap_rkey(file, buf, active_index, key, keypart_map,
 		       HA_READ_PREFIX_LAST);
-  table->status= error ? STATUS_NOT_FOUND : 0;
+  getTable()->status= error ? STATUS_NOT_FOUND : 0;
   return error;
 }
 
@@ -390,7 +390,7 @@
 {
   ha_statistic_increment(&system_status_var::ha_read_key_count);
   int error = heap_rkey(file, buf, index, key, keypart_map, find_flag);
-  table->status = error ? STATUS_NOT_FOUND : 0;
+  getTable()->status = error ? STATUS_NOT_FOUND : 0;
   return error;
 }
 
@@ -399,7 +399,7 @@
   assert(inited==INDEX);
   ha_statistic_increment(&system_status_var::ha_read_next_count);
   int error=heap_rnext(file,buf);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -408,7 +408,7 @@
   assert(inited==INDEX);
   ha_statistic_increment(&system_status_var::ha_read_prev_count);
   int error=heap_rprev(file,buf);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -417,7 +417,7 @@
   assert(inited==INDEX);
   ha_statistic_increment(&system_status_var::ha_read_first_count);
   int error=heap_rfirst(file, buf, active_index);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -426,7 +426,7 @@
   assert(inited==INDEX);
   ha_statistic_increment(&system_status_var::ha_read_last_count);
   int error=heap_rlast(file, buf, active_index);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -439,7 +439,7 @@
 {
   ha_statistic_increment(&system_status_var::ha_read_rnd_next_count);
   int error=heap_scan(file, buf);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -450,7 +450,7 @@
   ha_statistic_increment(&system_status_var::ha_read_rnd_count);
   memcpy(&heap_position, pos, sizeof(HEAP_PTR));
   error=heap_rrnd(file, buf, heap_position);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -499,7 +499,7 @@
 int ha_heap::delete_all_rows()
 {
   heap_clear(file);
-  if (table->getShare()->getType() == message::Table::STANDARD)
+  if (getTable()->getShare()->getType() == message::Table::STANDARD)
   {
     /*
        We can perform this safely since only one writer at the time is
@@ -634,7 +634,7 @@
 ha_rows ha_heap::records_in_range(uint32_t inx, key_range *min_key,
                                   key_range *max_key)
 {
-  KeyInfo *key= &table->key_info[inx];
+  KeyInfo *key= &getTable()->key_info[inx];
 
   if (!min_key || !max_key ||
       min_key->length != max_key->length ||

=== modified file 'plugin/memory/ha_heap.h'
--- plugin/memory/ha_heap.h	2010-10-02 21:15:42 +0000
+++ plugin/memory/ha_heap.h	2010-10-23 00:16:13 +0000
@@ -35,7 +35,7 @@
   uint32_t    key_stat_version;
   bool internal_table;
 public:
-  ha_heap(drizzled::plugin::StorageEngine &engine, drizzled::TableShare &table);
+  ha_heap(drizzled::plugin::StorageEngine &engine, drizzled::Table &table);
   ~ha_heap() {}
   Cursor *clone(drizzled::memory::Root *mem_root);
 

=== modified file 'plugin/myisam/ha_myisam.cc'
--- plugin/myisam/ha_myisam.cc	2010-10-02 21:15:42 +0000
+++ plugin/myisam/ha_myisam.cc	2010-10-23 00:16:13 +0000
@@ -104,7 +104,7 @@
     mi_panic(HA_PANIC_CLOSE);
   }
 
-  virtual Cursor *create(TableShare &table)
+  virtual Cursor *create(Table &table)
   {
     return new ha_myisam(*this, table);
   }
@@ -544,7 +544,7 @@
 }
 
 ha_myisam::ha_myisam(plugin::StorageEngine &engine_arg,
-                     TableShare &table_arg)
+                     Table &table_arg)
   : Cursor(engine_arg, table_arg),
   file(0),
   can_enable_indexes(true),
@@ -590,13 +590,13 @@
   if (!(file= mi_open(identifier, mode, test_if_locked)))
     return (errno ? errno : -1);
 
-  if (!table->getShare()->getType()) /* No need to perform a check for tmp table */
+  if (!getTable()->getShare()->getType()) /* No need to perform a check for tmp table */
   {
-    if ((errno= table2myisam(table, &keyinfo, &recinfo, &recs)))
+    if ((errno= table2myisam(getTable(), &keyinfo, &recinfo, &recs)))
     {
       goto err;
     }
-    if (check_definition(keyinfo, recinfo, table->getShare()->sizeKeys(), recs,
+    if (check_definition(keyinfo, recinfo, getTable()->getShare()->sizeKeys(), recs,
                          file->s->keyinfo, file->s->rec,
                          file->s->base.keys, file->s->base.fields, true))
     {
@@ -612,17 +612,17 @@
   info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
   if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))
     mi_extra(file, HA_EXTRA_WAIT_LOCK, 0);
-  if (!table->getShare()->db_record_offset)
+  if (!getTable()->getShare()->db_record_offset)
     is_ordered= false;
 
 
   keys_with_parts.reset();
-  for (i= 0; i < table->getShare()->sizeKeys(); i++)
+  for (i= 0; i < getTable()->getShare()->sizeKeys(); i++)
   {
-    table->key_info[i].block_size= file->s->keyinfo[i].block_length;
+    getTable()->key_info[i].block_size= file->s->keyinfo[i].block_length;
 
-    KeyPartInfo *kp= table->key_info[i].key_part;
-    KeyPartInfo *kp_end= kp + table->key_info[i].key_parts;
+    KeyPartInfo *kp= getTable()->key_info[i].key_part;
+    KeyPartInfo *kp_end= kp + getTable()->key_info[i].key_parts;
     for (; kp != kp_end; kp++)
     {
       if (!kp->field->part_of_key.test(i))
@@ -659,7 +659,7 @@
     If we have an auto_increment column and we are writing a changed row
     or a new row, then update the auto_increment value in the record.
   */
-  if (table->next_number_field && buf == table->getInsertRecord())
+  if (getTable()->next_number_field && buf == getTable()->getInsertRecord())
   {
     int error;
     if ((error= update_auto_increment()))
@@ -691,12 +691,12 @@
   {
     errmsg_printf(ERRMSG_LVL_INFO, "Retrying repair of: '%s' failed. "
                           "Please try REPAIR EXTENDED or myisamchk",
-                          table->getShare()->getPath());
+                          getTable()->getShare()->getPath());
     return(HA_ADMIN_FAILED);
   }
 
-  param.db_name=    table->getShare()->getSchemaName();
-  param.table_name= table->getAlias();
+  param.db_name=    getTable()->getShare()->getSchemaName();
+  param.table_name= getTable()->getAlias();
   param.tmpfile_createflag = O_RDWR | O_TRUNC;
   param.using_global_keycache = 1;
   param.session= session;
@@ -705,7 +705,7 @@
   strcpy(fixed_name,file->filename);
 
   // Don't lock tables if we have used LOCK Table
-  if (mi_lock_database(file, table->getShare()->getType() ? F_EXTRA_LCK : F_WRLCK))
+  if (mi_lock_database(file, getTable()->getShare()->getType() ? F_EXTRA_LCK : F_WRLCK))
   {
     mi_check_print_error(&param,ER(ER_CANT_LOCK),errno);
     return(HA_ADMIN_FAILED);
@@ -902,7 +902,7 @@
   }
   else if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE)
   {
-    Session *session= table->in_use;
+    Session *session= getTable()->in_use;
     MI_CHECK param;
     const char *save_proc_info= session->get_proc_info();
     session->set_proc_info("Creating index");
@@ -978,7 +978,7 @@
 
 void ha_myisam::start_bulk_insert(ha_rows rows)
 {
-  Session *session= table->in_use;
+  Session *session= getTable()->in_use;
   ulong size= session->variables.read_buff_size;
 
   /* don't enable row cache if too few rows */
@@ -1063,7 +1063,7 @@
   assert(inited==INDEX);
   ha_statistic_increment(&system_status_var::ha_read_key_count);
   int error=mi_rkey(file, buf, active_index, key, keypart_map, find_flag);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -1073,7 +1073,7 @@
 {
   ha_statistic_increment(&system_status_var::ha_read_key_count);
   int error=mi_rkey(file, buf, index, key, keypart_map, find_flag);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -1084,7 +1084,7 @@
   ha_statistic_increment(&system_status_var::ha_read_key_count);
   int error=mi_rkey(file, buf, active_index, key, keypart_map,
                     HA_READ_PREFIX_LAST);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return(error);
 }
 
@@ -1093,7 +1093,7 @@
   assert(inited==INDEX);
   ha_statistic_increment(&system_status_var::ha_read_next_count);
   int error=mi_rnext(file,buf,active_index);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -1102,7 +1102,7 @@
   assert(inited==INDEX);
   ha_statistic_increment(&system_status_var::ha_read_prev_count);
   int error=mi_rprev(file,buf, active_index);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -1111,7 +1111,7 @@
   assert(inited==INDEX);
   ha_statistic_increment(&system_status_var::ha_read_first_count);
   int error=mi_rfirst(file, buf, active_index);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -1120,7 +1120,7 @@
   assert(inited==INDEX);
   ha_statistic_increment(&system_status_var::ha_read_last_count);
   int error=mi_rlast(file, buf, active_index);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -1135,7 +1135,7 @@
   {
     error= mi_rnext_same(file,buf);
   } while (error == HA_ERR_RECORD_DELETED);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -1176,7 +1176,7 @@
 {
   ha_statistic_increment(&system_status_var::ha_read_rnd_next_count);
   int error=mi_scan(file, buf);
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -1184,7 +1184,7 @@
 {
   ha_statistic_increment(&system_status_var::ha_read_rnd_count);
   int error=mi_rrnd(file, buf, internal::my_get_ptr(pos,ref_length));
-  table->status=error ? STATUS_NOT_FOUND: 0;
+  getTable()->status=error ? STATUS_NOT_FOUND: 0;
   return error;
 }
 
@@ -1213,7 +1213,7 @@
   }
   if (flag & HA_STATUS_CONST)
   {
-    TableShare *share= table->getMutableShare();
+    TableShare *share= getTable()->getMutableShare();
     stats.max_data_file_length=  misam_info.max_data_file_length;
     stats.max_index_file_length= misam_info.max_index_file_length;
     stats.create_time= misam_info.create_time;
@@ -1270,9 +1270,9 @@
     share->keys_for_keyread&= share->keys_in_use;
     share->db_record_offset= misam_info.record_offset;
     if (share->key_parts)
-      memcpy(table->key_info[0].rec_per_key,
+      memcpy(getTable()->key_info[0].rec_per_key,
 	     misam_info.rec_per_key,
-	     sizeof(table->key_info[0].rec_per_key)*share->key_parts);
+	     sizeof(getTable()->key_info[0].rec_per_key)*share->key_parts);
     assert(share->getType() != message::Table::STANDARD);
 
    /*
@@ -1337,7 +1337,7 @@
 int ha_myisam::external_lock(Session *session, int lock_type)
 {
   file->in_use= session;
-  return mi_lock_database(file, !table->getShare()->getType() ?
+  return mi_lock_database(file, !getTable()->getShare()->getType() ?
 			  lock_type : ((lock_type == F_UNLCK) ?
 				       F_UNLCK : F_EXTRA_LCK));
 }
@@ -1408,7 +1408,7 @@
   int error;
   unsigned char key[MI_MAX_KEY_LENGTH];
 
-  if (!table->getShare()->next_number_key_offset)
+  if (!getTable()->getShare()->next_number_key_offset)
   {						// Autoincrement at key-start
     ha_myisam::info(HA_STATUS_AUTO);
     *first_value= stats.auto_increment_value;
@@ -1418,22 +1418,22 @@
   }
 
   /* it's safe to call the following if bulk_insert isn't on */
-  mi_flush_bulk_insert(file, table->getShare()->next_number_index);
+  mi_flush_bulk_insert(file, getTable()->getShare()->next_number_index);
 
   (void) extra(HA_EXTRA_KEYREAD);
-  key_copy(key, table->getInsertRecord(),
-           &table->key_info[table->getShare()->next_number_index],
-           table->getShare()->next_number_key_offset);
-  error= mi_rkey(file, table->getUpdateRecord(), (int) table->getShare()->next_number_index,
-                 key, make_prev_keypart_map(table->getShare()->next_number_keypart),
+  key_copy(key, getTable()->getInsertRecord(),
+           &getTable()->key_info[getTable()->getShare()->next_number_index],
+           getTable()->getShare()->next_number_key_offset);
+  error= mi_rkey(file, getTable()->getUpdateRecord(), (int) getTable()->getShare()->next_number_index,
+                 key, make_prev_keypart_map(getTable()->getShare()->next_number_keypart),
                  HA_READ_PREFIX_LAST);
   if (error)
     nr= 1;
   else
   {
     /* Get data from getUpdateRecord() */
-    nr= ((uint64_t) table->next_number_field->
-         val_int_offset(table->getShare()->rec_buff_length)+1);
+    nr= ((uint64_t) getTable()->next_number_field->
+         val_int_offset(getTable()->getShare()->rec_buff_length)+1);
   }
   extra(HA_EXTRA_NO_KEYREAD);
   *first_value= nr;

=== modified file 'plugin/myisam/ha_myisam.h'
--- plugin/myisam/ha_myisam.h	2010-10-02 21:15:42 +0000
+++ plugin/myisam/ha_myisam.h	2010-10-23 00:16:13 +0000
@@ -34,7 +34,7 @@
 
  public:
   ha_myisam(drizzled::plugin::StorageEngine &engine,
-            drizzled::TableShare &table_arg);
+            drizzled::Table &table_arg);
   ~ha_myisam() {}
   Cursor *clone(drizzled::memory::Root *mem_root);
   const char *index_type(uint32_t key_number);

=== modified file 'plugin/pbms/src/ha_pbms.cc'
--- plugin/pbms/src/ha_pbms.cc	2010-10-18 21:21:20 +0000
+++ plugin/pbms/src/ha_pbms.cc	2010-10-23 00:16:13 +0000
@@ -114,7 +114,7 @@
 	int doStartTransaction(Session *session, start_transaction_option_t options);
 	int doCommit(Session *, bool);
 	int doRollback(Session *, bool);
-	Cursor *create(TableShare& table);
+	Cursor *create(Table& table);
 	bool doDropSchema(const drizzled::SchemaIdentifier&);
 	
 	/*
@@ -257,7 +257,7 @@
 
 
 #ifdef DRIZZLED
-Cursor *PBMSStorageEngine::create(TableShare& table)
+Cursor *PBMSStorageEngine::create(Table& table)
 {
 	PBMSStorageEngine * const hton = this;
 	return new ha_pbms(hton, table);
@@ -655,7 +655,7 @@
 }
 
 #ifdef DRIZZLED
-ha_pbms::ha_pbms(handlerton *hton, TableShare& table_arg) : handler(*hton, table_arg),
+ha_pbms::ha_pbms(handlerton *hton, Table& table_arg) : handler(*hton, table_arg),
 #else
 ha_pbms::ha_pbms(handlerton *hton, TABLE_SHARE *table_arg) : handler(hton, table_arg),
 #endif
@@ -696,7 +696,7 @@
 
 	inner_();
 	try_(a) {
-		ha_open_tab = MSSystemTableShare::openSystemTable(table_path, table);
+		ha_open_tab = MSSystemTableShare::openSystemTable(table_path, getTable());
 #ifdef DRIZZLED
 		ha_lock.init(&ha_open_tab->myShare->myThrLock);
 #else

=== modified file 'plugin/pbms/src/ha_pbms.h'
--- plugin/pbms/src/ha_pbms.h	2010-10-02 21:15:42 +0000
+++ plugin/pbms/src/ha_pbms.h	2010-10-23 00:16:13 +0000
@@ -66,7 +66,7 @@
 
 public:
 #ifdef DRIZZLED
-	ha_pbms(handlerton *hton, TableShare& table_arg);
+	ha_pbms(handlerton *hton, Table& table_arg);
 #else
 	ha_pbms(handlerton *hton, TABLE_SHARE *table_arg);
 #endif

=== modified file 'plugin/pbxt/src/ha_pbxt.cc'
--- plugin/pbxt/src/ha_pbxt.cc	2010-10-09 10:57:54 +0000
+++ plugin/pbxt/src/ha_pbxt.cc	2010-10-23 00:16:13 +0000
@@ -1482,7 +1482,7 @@
 	return 0;
 }
 
-Cursor *PBXTStorageEngine::create(TableShare& table)
+Cursor *PBXTStorageEngine::create(Table& table)
 {
 	return new ha_pbxt(*this, table);
 }
@@ -2020,7 +2020,7 @@
  *
  */
 
-ha_pbxt::ha_pbxt(plugin::StorageEngine &engine_arg, TableShare &table_arg) : Cursor(engine_arg, table_arg)
+ha_pbxt::ha_pbxt(plugin::StorageEngine &engine_arg, Table &table_arg) : Cursor(engine_arg, table_arg)
 {
 	pb_share = NULL;
 	pb_open_tab = NULL;
@@ -2351,9 +2351,9 @@
 		return;
 
 	xt_spinlock_lock(&tab->tab_ainc_lock);
-	if (table->found_next_number_field && !tab->tab_auto_inc) {
-		Field		*tmp_fie = table->next_number_field;
-		THD			*tmp_thd = table->in_use;
+	if (getTable()->found_next_number_field && !tab->tab_auto_inc) {
+		Field		*tmp_fie = getTable()->next_number_field;
+		THD			*tmp_thd = getTable()->in_use;
 		xtBool		xn_started = FALSE;
 		XTThreadPtr	self = pb_open_tab->ot_thread;
 
@@ -2381,19 +2381,19 @@
 		}
 
 		/* Setup the conditions for the next call! */
-		table->in_use = current_thd;
-		table->next_number_field = table->found_next_number_field;
+		getTable()->in_use = current_thd;
+		getTable()->next_number_field = getTable()->found_next_number_field;
 
 		extra(HA_EXTRA_KEYREAD);
-		table->mark_columns_used_by_index_no_reset(table->getShare()->next_number_index, *table->read_set);
+		getTable()->mark_columns_used_by_index_no_reset(getTable()->getShare()->next_number_index, *getTable()->read_set);
 		column_bitmaps_signal();
- 		doStartIndexScan(table->getShare()->next_number_index, 0);
-		if (!table->getShare()->next_number_key_offset) {
+ 		doStartIndexScan(getTable()->getShare()->next_number_index, 0);
+		if (!getTable()->getShare()->next_number_key_offset) {
 			// Autoincrement at key-start
-			err = index_last(table->getUpdateRecord());
-			if (!err && !table->next_number_field->is_null(table->getShare()->rec_buff_length)) {
+			err = index_last(getTable()->getUpdateRecord());
+			if (!err && !getTable()->next_number_field->is_null(getTable()->getShare()->rec_buff_length)) {
 				/* {PRE-INC} */
-				nr = (xtWord8) table->next_number_field->val_int_offset(table->getShare()->rec_buff_length);
+				nr = (xtWord8) getTable()->next_number_field->val_int_offset(getTable()->getShare()->rec_buff_length);
 			}
 		}
 		else {
@@ -2403,13 +2403,13 @@
 			 */
 			xtWord8 val;
 
-			err = index_first(table->getUpdateRecord());
+			err = index_first(getTable()->getUpdateRecord());
 			while (!err) {
 				/* {PRE-INC} */
-				val = (xtWord8) table->next_number_field->val_int_offset(table->getShare()->rec_buff_length);
+				val = (xtWord8) getTable()->next_number_field->val_int_offset(getTable()->getShare()->rec_buff_length);
 				if (val > nr)
 					nr = val;
-				err = index_next(table->getUpdateRecord());
+				err = index_next(getTable()->getUpdateRecord());
 			}
 		}
 
@@ -2444,8 +2444,8 @@
 			tab->tab_auto_inc = min_auto_inc-1;
 
 		/* Restore the changed values: */
-		table->next_number_field = tmp_fie;
-		table->in_use = tmp_thd;
+		getTable()->next_number_field = tmp_fie;
+		getTable()->in_use = tmp_thd;
 
 		if (xn_started) {
 			XT_PRINT0(self, "xt_xn_commit in init_auto_increment\n");
@@ -2480,7 +2480,7 @@
 		nr += increment - ((nr - offset) % increment);
 	else
 		nr += increment;
-	if (table->next_number_field->cmp((const unsigned char *)&nr_less_inc, (const unsigned char *)&nr) < 0)
+	if (getTable()->next_number_field->cmp((const unsigned char *)&nr_less_inc, (const unsigned char *)&nr) < 0)
 		tab->tab_auto_inc = (xtWord8) (nr);
 	else
 		nr = ~0;	/* indicate error to the caller */
@@ -2610,14 +2610,14 @@
 			pb_import_row_count++;
 	}
 
-	if (table->next_number_field && buf == table->getInsertRecord()) {
+	if (getTable()->next_number_field && buf == getTable()->getInsertRecord()) {
 		int update_err = update_auto_increment();
 		if (update_err) {
 			ha_log_pbxt_thread_error_for_mysql(pb_ignore_dup_key);
 			err = update_err;
 			goto done;
 		}
-		ha_set_auto_increment(pb_open_tab, table->next_number_field);
+		ha_set_auto_increment(pb_open_tab, getTable()->next_number_field);
 	}
 
 	if (!xt_tab_new_record(pb_open_tab, (xtWord1 *) buf)) {
@@ -2735,12 +2735,12 @@
 	 * update t1 set a=2 where a=1;
 	 * insert into t1 (val) values (1);
 	 */
-	if (table->found_next_number_field && new_data == table->getInsertRecord()) {
+	if (getTable()->found_next_number_field && new_data == getTable()->getInsertRecord()) {
 		MX_LONGLONG_T	nr;
-        const boost::dynamic_bitset<>& old_bitmap= table->use_all_columns(*table->read_set);
-		nr = table->found_next_number_field->val_int();
-		ha_set_auto_increment(pb_open_tab, table->found_next_number_field);
-        table->restore_column_map(old_bitmap);
+        const boost::dynamic_bitset<>& old_bitmap= getTable()->use_all_columns(*getTable()->read_set);
+		nr = getTable()->found_next_number_field->val_int();
+		ha_set_auto_increment(pb_open_tab, getTable()->found_next_number_field);
+        getTable()->restore_column_map(old_bitmap);
 	}
 
 	if (!xt_tab_update_record(pb_open_tab, (xtWord1 *) old_data, (xtWord1 *) new_data))
@@ -3134,7 +3134,7 @@
 	/* The number of columns required: */
 	if (pb_open_tab->ot_is_modify) {
 
-		pb_open_tab->ot_cols_req = table->read_set->MX_BIT_SIZE();
+		pb_open_tab->ot_cols_req = getTable()->read_set->MX_BIT_SIZE();
 #ifdef XT_PRINT_INDEX_OPT
 		ind = (XTIndexPtr) pb_share->sh_dic_keys[idx];
 
@@ -3149,7 +3149,7 @@
 	}
 	else {
 		//pb_open_tab->ot_cols_req = ha_get_max_bit(table->read_set);
-		pb_open_tab->ot_cols_req = table->read_set->MX_BIT_SIZE();
+		pb_open_tab->ot_cols_req = getTable()->read_set->MX_BIT_SIZE();
 
 		/* Check for index coverage!
 		 *
@@ -3200,9 +3200,9 @@
          */
         std::string bitmap_str= convert_long_to_bit_string(ind->mi_col_map, ind->mi_col_map_size);
         MX_BITMAP tmp(bitmap_str);
-		if (MX_BIT_IS_SUBSET(table->read_set, tmp))
+		if (MX_BIT_IS_SUBSET(getTable()->read_set, tmp))
 #else
-		if (MX_BIT_IS_SUBSET(table->read_set, ind->mi_col_map))
+		if (MX_BIT_IS_SUBSET(getTable()->read_set, ind->mi_col_map))
 #endif
 			pb_key_read = TRUE;
 #ifdef XT_PRINT_INDEX_OPT
@@ -3347,10 +3347,10 @@
 	XT_DISABLED_TRACE(("search tx=%d val=%d err=%d\n", (int) pb_open_tab->ot_thread->st_xact_data->xd_start_xn_id, (int) XT_GET_DISK_4(key), err));
 	done:
 	if (err)
-		table->status = STATUS_NOT_FOUND;
+		getTable()->status = STATUS_NOT_FOUND;
 	else {
 		pb_open_tab->ot_thread->st_statistics.st_row_select++;
-		table->status = 0;
+		getTable()->status = 0;
 	}
 	return err;
 }
@@ -3408,10 +3408,10 @@
 #endif
 	done:
 	if (err)
-		table->status = STATUS_NOT_FOUND;
+		getTable()->status = STATUS_NOT_FOUND;
 	else {
 		pb_open_tab->ot_thread->st_statistics.st_row_select++;
-		table->status = 0;
+		getTable()->status = 0;
 	}
 	XT_RETURN(err);
 }
@@ -3462,10 +3462,10 @@
 #endif
 	done:
 	if (err)
-		table->status = STATUS_NOT_FOUND;
+		getTable()->status = STATUS_NOT_FOUND;
 	else {
 		pb_open_tab->ot_thread->st_statistics.st_row_select++;
-		table->status = 0;
+		getTable()->status = 0;
 	}
 	XT_RETURN(err);
 }
@@ -3500,10 +3500,10 @@
 #endif
 	done:
 	if (err)
-		table->status = STATUS_NOT_FOUND;
+		getTable()->status = STATUS_NOT_FOUND;
 	else {
 		pb_open_tab->ot_thread->st_statistics.st_row_select++;
-		table->status = 0;
+		getTable()->status = 0;
 	}
 	XT_RETURN(err);
 }
@@ -3553,10 +3553,10 @@
 #endif
 	done:
 	if (err)
-		table->status = STATUS_NOT_FOUND;
+		getTable()->status = STATUS_NOT_FOUND;
 	else {
 		pb_open_tab->ot_thread->st_statistics.st_row_select++;
-		table->status = 0;
+		getTable()->status = 0;
 	}
 	XT_RETURN(err);
 }
@@ -3599,10 +3599,10 @@
 #endif
 	done:
 	if (err)
-		table->status = STATUS_NOT_FOUND;
+		getTable()->status = STATUS_NOT_FOUND;
 	else {
 		pb_open_tab->ot_thread->st_statistics.st_row_select++;
-		table->status = 0;
+		getTable()->status = 0;
 	}
 	XT_RETURN(err);
 }
@@ -3646,7 +3646,7 @@
 
 	/* The number of columns required: */
 	if (pb_open_tab->ot_is_modify) {
-		pb_open_tab->ot_cols_req = table->read_set->MX_BIT_SIZE();
+		pb_open_tab->ot_cols_req = getTable()->read_set->MX_BIT_SIZE();
 		/* {START-STAT-HACK} previously position of start statement hack,
 		 * previous comment to code below: */
 		/* Start a statement based transaction as soon
@@ -3656,7 +3656,7 @@
 	}
 	else {
 		//pb_open_tab->ot_cols_req = ha_get_max_bit(table->read_set);
-		pb_open_tab->ot_cols_req = table->read_set->MX_BIT_SIZE();
+		pb_open_tab->ot_cols_req = getTable()->read_set->MX_BIT_SIZE();
 
 		/*
 		 * in case of queries like SELECT COUNT(*) FROM t
@@ -3726,10 +3726,10 @@
 		err = HA_ERR_END_OF_FILE;
 
 	if (err)
-		table->status = STATUS_NOT_FOUND;
+		getTable()->status = STATUS_NOT_FOUND;
 	else {
 		pb_open_tab->ot_thread->st_statistics.st_row_select++;
-		table->status = 0;
+		getTable()->status = 0;
 	}
 	XT_RETURN(err);
 }
@@ -3801,10 +3801,10 @@
 	}		
 
 	if (err)
-		table->status = STATUS_NOT_FOUND;
+		getTable()->status = STATUS_NOT_FOUND;
 	else {
 		pb_open_tab->ot_thread->st_statistics.st_row_select++;
-		table->status = 0;
+		getTable()->status = 0;
 	}
 	XT_RETURN(err);
 }

=== modified file 'plugin/pbxt/src/ha_pbxt.h'
--- plugin/pbxt/src/ha_pbxt.h	2010-10-06 18:22:02 +0000
+++ plugin/pbxt/src/ha_pbxt.h	2010-10-23 00:16:13 +0000
@@ -80,7 +80,7 @@
 	/* override */ int close_connection(Session *);
 	/* override */ int commit(Session *, bool);
 	/* override */ int rollback(Session *, bool);
-	/* override */ Cursor *create(TableShare&);
+	/* override */ Cursor *create(Table&);
 	/* override */ void drop_database(char *);
 	/* override */ bool show_status(Session *, stat_print_fn *, enum ha_stat_type);
         /* override */ const char **bas_ext() const;
@@ -174,7 +174,7 @@
 	THD					*pb_mysql_thd;			/* A pointer to the MySQL thread. */
 	xtBool				pb_in_stat;				/* TRUE of start_stmt() was issued */
 
-	ha_pbxt(plugin::StorageEngine &engine_arg, TableShare &table_arg);
+	ha_pbxt(plugin::StorageEngine &engine_arg, Table &table_arg);
 	virtual ~ha_pbxt() { }
 
 	/* The name that will be used for display purposes */

=== modified file 'plugin/pbxt/src/ha_xtsys.cc'
--- plugin/pbxt/src/ha_xtsys.cc	2010-10-02 21:15:42 +0000
+++ plugin/pbxt/src/ha_xtsys.cc	2010-10-23 00:16:13 +0000
@@ -59,7 +59,7 @@
  */
 
 #ifdef DRIZZLED
-ha_xtsys::ha_xtsys(handlerton *hton, TableShare& table_arg):
+ha_xtsys::ha_xtsys(handlerton *hton, Table& table_arg):
 handler(*hton, table_arg),
 ha_open_tab(NULL)
 {
@@ -96,7 +96,7 @@
 	try_(a) {
 		xt_ha_open_database_of_table(self, (XTPathStrPtr) table_path);
 
-		ha_open_tab = XTSystemTableShare::openSystemTable(self, table_path, table);
+		ha_open_tab = XTSystemTableShare::openSystemTable(self, table_path, getTable());
 		MYSQL_INIT_LOCK(ha_lock, ha_open_tab->ost_share->sts_my_lock);
 		ref_length = ha_open_tab->getRefLen();
 	}

=== modified file 'plugin/pbxt/src/ha_xtsys.h'
--- plugin/pbxt/src/ha_xtsys.h	2010-10-02 21:15:42 +0000
+++ plugin/pbxt/src/ha_xtsys.h	2010-10-23 00:16:13 +0000
@@ -59,7 +59,7 @@
 
 public:
 #ifdef DRIZZLED
-	ha_xtsys(handlerton *hton, TableShare& table_arg);
+	ha_xtsys(handlerton *hton, Table& table_arg);
 #else
 	ha_xtsys(handlerton *hton, TABLE_SHARE *table_arg);
 #endif

=== modified file 'plugin/schema_engine/schema.h'
--- plugin/schema_engine/schema.h	2010-10-09 01:10:07 +0000
+++ plugin/schema_engine/schema.h	2010-10-23 00:16:13 +0000
@@ -53,7 +53,7 @@
 
   bool doCanCreateTable(const drizzled::TableIdentifier &identifier);
 
-  drizzled::Cursor *create(drizzled::TableShare &)
+  drizzled::Cursor *create(drizzled::Table &)
   {
     return NULL;
   }

=== modified file 'plugin/tableprototester/tableprototester.cc'
--- plugin/tableprototester/tableprototester.cc	2010-09-23 01:53:13 +0000
+++ plugin/tableprototester/tableprototester.cc	2010-10-23 00:16:13 +0000
@@ -57,7 +57,7 @@
     table_definition_ext= TABLEPROTOTESTER_EXT;
   }
 
-  virtual Cursor *create(TableShare &table)
+  virtual Cursor *create(Table &table)
   {
     return new TableProtoTesterCursor(*this, table);
   }
@@ -128,7 +128,7 @@
 }
 
 TableProtoTesterCursor::TableProtoTesterCursor(drizzled::plugin::StorageEngine &engine_arg,
-                           TableShare &table_arg) :
+                                               Table &table_arg) :
   Cursor(engine_arg, table_arg)
 { }
 
@@ -263,7 +263,7 @@
 
 int TableProtoTesterCursor::doInsertRecord(unsigned char *)
 {
-  return(table->next_number_field ? update_auto_increment() : 0);
+  return(getTable()->next_number_field ? update_auto_increment() : 0);
 }
 
 int TableProtoTesterCursor::doStartTableScan(bool)

=== modified file 'plugin/tableprototester/tableprototester.h'
--- plugin/tableprototester/tableprototester.h	2010-04-23 17:43:11 +0000
+++ plugin/tableprototester/tableprototester.h	2010-10-23 00:16:13 +0000
@@ -24,7 +24,7 @@
 class TableProtoTesterCursor: public drizzled::Cursor
 {
 public:
-  TableProtoTesterCursor(drizzled::plugin::StorageEngine &engine, drizzled::TableShare &table_arg);
+  TableProtoTesterCursor(drizzled::plugin::StorageEngine &engine, drizzled::Table &table_arg);
   ~TableProtoTesterCursor()
   {}