Merge lp:~posulliv/drizzle/info-schema-storage-engine into lp:~drizzle-trunk/drizzle/development

[Padraig O'Sullivan]

[Padraig O'Sullivan (posulliv)]

I'm looking to get some help with my I_S engine if anyone has some time. I'm proposing it for merging so that its easier for people to see the changes I have made. I'm still trying to keep looking at this when I get some spare time so I'm still working on it, just not as much as I would like to be.

I'm pretty close (I believe) to having a working I_S engine. The main issue I'm having right now is with the COLUMN_DEFAULT column in the COLUMNS table. It is throwing warnings whenever I do a select on the COLUMNS table.

But besides that, it would be nice to get some input on what I have done so far. I feel like it would be good to get some input on this engine as its a large patch and it would be nice to know whether people think I am going in the right direction or not. I want to make sure I am not going off on a tangent or anything!

-Padraig

[Jay Pipes (jaypipes)]

Hi Padraig!

A few comments and questions... :)

1) Per our IRC conversation, you should put back the ASSERT_COLUMN_MARKED_FOR_WRITE macros in /field/int64_t.cc and /field/long.cc.

2) What was the reasoning behind this change?

8 -#define PROCESS_LIST_INFO_WIDTH 65535
9 +#define PROCESS_LIST_INFO_WIDTH 16383

3) When I saw this removed from drizzled/join.cc:

92 - if ((this->select_lex->options & OPTION_SCHEMA_TABLE) && get_schema_tables_result(this, PROCESSED_BY_JOIN_EXEC))
93 - return;
94 -

and this removed from drizzled/sql_base.cc:

1070 - /*
1071 - If this TableList object is a placeholder for an information_schema
1072 - table, create a temporary table to represent the information_schema
1073 - table in the query. Do not fill it yet - will be filled during
1074 - execution.
1075 - */
1076 - if (tables->schema_table)
1077 - {
1078 - if (mysql_schema_table(this, lex, tables) == false)
1079 - continue;
1080 - return -1;
1081 - }

I had a little celebration :) No more two different code paths just for selecting from the information_schema \o/ epic win.

4) The following code needs to have the comment removed :)

237 + void addRow(unsigned char *buf, size_t len)
238 + {
239 + /*unsigned char *my_buf= new
240 + unsigned char[len];
241 + memcpy(my_buf, buf, len);
242 + rows.push_back(my_buf);*/
243 + InfoSchemaRecord tmp_rec(buf, len);
244 + rows.push_back(tmp_rec);
245 + }

Also, rows is defined as std::vector<InfoSchemaRecord>. Perhaps it is worth making this std::vector<InfoSchemaRecord *> instead and making the addRow() method this:

void addRow(unsigned char *buf, size_t len)
{
  InfoSchemaRecord *record= new InfoSchemaRecord(buf, len);
  rows.push_back(record);
}

and then cleaning up all those new'd records when the InfoSchemaTable is destroyed (in other words, have the InfoSchemaRecord manage all memory allocation instead of std::vector<>. This would be a little more efficient, as one less memcpy() would be used for each addRow() call.

5) I found this code to be awkward:

434 - error= test(schema_table->processTable(session, show_table_list,
435 - table, res, db_name,
436 + error= test(schema_table->processTable(schema_table,
437 + session,
438 + show_table_list,
439 + table,
440 + res,
441 + db_name,

Why is the first param of processTable() schema_table? I mean, "this" would refer to schema_table, no?

6) Indentation off by one here:

699 - XXX-> show_table_list has a flag i_is_requested,
700 - and when it's set, openTables()
701 - can return an error without setting an error message
702 - in Session, which is a hack. This is why we have to
703 - check for res, then for session->is_error() only then
704 - for session->main_da.sql_errno().
705 - */
706 + XXX-> show_table_list has a flag i_is_requested,
707 + and when it's set, openTables()
708 + can return an error without setting an error message
709 + in Session, which is a hack. This is why we have to
710 + check for res, then for session->is_error() only then
711 + for session->main_da.sql_errno().
712 + */

717 - Hide error for not existing table.
718 - This error can occur for example when we use
719 - where condition with db name and table name and this
720 - table does n...

[lp:~posulliv/drizzle/info-schema-storage-engine]

1161. By Padraig O'Sullivan on 2009-10-19

Merge from trunk.

1162. By Padraig O'Sullivan on 2009-10-19

Resolved conflicts from the latest merge with trunk.

1163. By Padraig O'Sullivan on 2009-10-20

Removed a redundant field from the InfoSchemaColumn class. This allowed us
to remove some redundant flags.

1164. By Padraig O'Sullivan on 2009-10-29

Modified the fillTable() method to not take a COND as a parameter any more.

1165. By Padraig O'Sullivan on 2009-10-29

Merge from trunk.

1166. By Padraig O'Sullivan on 2009-10-29

Reworked the processTable() method parameters to be more sane.

1167. By Padraig O'Sullivan on 2009-10-29

Taking Jay's review suggestion to change Rows from vector<InfoSchemaRecord>
to vector<InfoSchemaRecord *>.

Thanks Jay!

1168. By Padraig O'Sullivan on 2009-10-29

Apparently, changing the size of a column in an I_S table makes query
execution work differently...isn't that just magical???

So I changed the length of the COLUMN_TYPE column in the COLUMNS table and
some queries from the I_S test case that didn't work before now
work...great.

I also changed rnd_pos to return HA_ERR_WRONG_COMMAND so I can see where it
is getting called from. I need to implement rnd_pos and position next.

Some good progress was made tonight though...When I get the 2 methods above
implemented, I should be very very close to having this damn thing working
(although knowing I_S, it will be probably crash and burn for no apparent
reason..)

[Brian Aker (brianaker)]

This has been pulled in now (relevant bits were merged).

Unmerged revisions

1168. By Padraig O'Sullivan on 2009-10-29

Apparently, changing the size of a column in an I_S table makes query
execution work differently...isn't that just magical???

So I changed the length of the COLUMN_TYPE column in the COLUMNS table and
some queries from the I_S test case that didn't work before now
work...great.

I also changed rnd_pos to return HA_ERR_WRONG_COMMAND so I can see where it
is getting called from. I need to implement rnd_pos and position next.

Some good progress was made tonight though...When I get the 2 methods above
implemented, I should be very very close to having this damn thing working
(although knowing I_S, it will be probably crash and burn for no apparent
reason..)

1167. By Padraig O'Sullivan on 2009-10-29

Taking Jay's review suggestion to change Rows from vector<InfoSchemaRecord>
to vector<InfoSchemaRecord *>.

Thanks Jay!

1166. By Padraig O'Sullivan on 2009-10-29

Reworked the processTable() method parameters to be more sane.

1165. By Padraig O'Sullivan on 2009-10-29

Merge from trunk.

1164. By Padraig O'Sullivan on 2009-10-29

Modified the fillTable() method to not take a COND as a parameter any more.

1163. By Padraig O'Sullivan on 2009-10-20

Removed a redundant field from the InfoSchemaColumn class. This allowed us
to remove some redundant flags.

1162. By Padraig O'Sullivan on 2009-10-19

Resolved conflicts from the latest merge with trunk.

1161. By Padraig O'Sullivan on 2009-10-19

Merge from trunk.

1160. By Padraig O'Sullivan on 2009-10-18

Moved a statement into a conditional block where it actually belonged in the
first place.

1159. By Padraig O'Sullivan on 2009-10-18

Corrected the destructor in the InfoSchemaRecord class.

=== modified file 'drizzled/definitions.h'
--- drizzled/definitions.h	2009-10-21 00:14:57 +0000
+++ drizzled/definitions.h	2009-10-29 23:56:13 +0000
@@ -226,7 +226,7 @@
 /** Characters shown for the command in 'show processlist'. */
 #define PROCESS_LIST_WIDTH 100
 /* Characters shown for the command in 'information_schema.processlist' */
-#define PROCESS_LIST_INFO_WIDTH 65535
+#define PROCESS_LIST_INFO_WIDTH 16383
 
 #define PRECISION_FOR_DOUBLE 53
 #define PRECISION_FOR_FLOAT  24
@@ -527,10 +527,6 @@
 #define MY_I_S_UNSIGNED   2
 
 
-#define SKIP_OPEN_TABLE 0                // do not open table
-#define OPEN_FRM_ONLY   1                // open FRM file only
-#define OPEN_FULL_TABLE 2                // open FRM,MYD, MYI files
-
 /*
    "Declared Type Collation"
    A combination of collation and its derivation.
 
=== modified file 'drizzled/field/int64_t.cc'
--- drizzled/field/int64_t.cc	2009-07-10 00:01:50 +0000
+++ drizzled/field/int64_t.cc	2009-10-29 23:56:14 +0000
@@ -40,7 +40,7 @@
   char *end;
   uint64_t tmp;
 
-  ASSERT_COLUMN_MARKED_FOR_WRITE;
+  //ASSERT_COLUMN_MARKED_FOR_WRITE;
 
   tmp= cs->cset->strntoull10rnd(cs, from, len, false, &end,&error);
   if (error == MY_ERRNO_ERANGE)
@@ -70,7 +70,7 @@
   int error= 0;
   int64_t res;
 
-  ASSERT_COLUMN_MARKED_FOR_WRITE;
+  //ASSERT_COLUMN_MARKED_FOR_WRITE;
 
   nr= rint(nr);
 
@@ -106,7 +106,7 @@
 {
   int error= 0;
 
-  ASSERT_COLUMN_MARKED_FOR_WRITE;
+  //ASSERT_COLUMN_MARKED_FOR_WRITE;
 
 #ifdef WORDS_BIGENDIAN
   if (table->s->db_low_byte_first)
@@ -124,7 +124,7 @@
 {
   int64_t j;
 
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  //ASSERT_COLUMN_MARKED_FOR_READ;
 
 #ifdef WORDS_BIGENDIAN
   if (table->s->db_low_byte_first)
@@ -143,7 +143,7 @@
 {
   int64_t j;
 
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  //ASSERT_COLUMN_MARKED_FOR_READ;
 
 #ifdef WORDS_BIGENDIAN
   if (table->s->db_low_byte_first)
@@ -165,7 +165,7 @@
   char *to=(char*) val_buffer->ptr();
   int64_t j;
 
-  ASSERT_COLUMN_MARKED_FOR_READ;
+  //ASSERT_COLUMN_MARKED_FOR_READ;
 
 #ifdef WORDS_BIGENDIAN
   if (table->s->db_low_byte_first)
 
=== modified file 'drizzled/field/long.cc'
--- drizzled/field/long.cc	2009-07-10 00:01:50 +0000
+++ drizzled/field/long.cc	2009-10-29 23:56:14 +0000
@@ -62,7 +62,7 @@
   int32_t res;
   nr=rint(nr);
 
-  ASSERT_COLUMN_MARKED_FOR_WRITE;
+  //ASSERT_COLUMN_MARKED_FOR_WRITE;
 
   if (nr < (double) INT32_MIN)
   {
 
=== modified file 'drizzled/join.cc'
--- drizzled/join.cc	2009-10-06 19:51:49 +0000
+++ drizzled/join.cc	2009-10-29 23:56:13 +0000
@@ -1245,9 +1245,6 @@
     return;
   }
 
-  if ((this->select_lex->options & OPTION_SCHEMA_TABLE) && get_schema_tables_result(this, PROCESSED_BY_JOIN_EXEC))
-    return;
-
   if (select_options & SELECT_DESCRIBE)
   {
     /*
 
=== modified file 'drizzled/plugin/info_schema_table.h'
--- drizzled/plugin/info_schema_table.h	2009-10-06 19:14:39 +0000
+++ drizzled/plugin/info_schema_table.h	2009-10-29 23:56:14 +0000
@@ -25,6 +25,9 @@
 
 namespace drizzled
 {
+
+extern std::vector<plugin::InfoSchemaTable *> all_schema_tables;
+
 namespace plugin
 {
 
@@ -35,9 +38,6 @@
  *   Header file which contains all classes related to I_S
  */
 
-typedef class Item COND;
-
-
 /**
  * @class ColumnInfo
  * @brief
@@ -51,16 +51,14 @@
              enum enum_field_types in_type,
              int32_t in_value,
              uint32_t in_flags,
-             const std::string& in_old_name,
-             uint32_t in_open_method)
+             const std::string& in_old_name)
     :
       name(in_name),
       length(in_length),
       type(in_type),
       value(in_value),
       flags(in_flags),
-      old_name(in_old_name),
-      open_method(in_open_method)
+      old_name(in_old_name)
   {}
 
   ColumnInfo()
@@ -69,8 +67,7 @@
       length(0),
       type(DRIZZLE_TYPE_VARCHAR),
       flags(0),
-      old_name(),
-      open_method(SKIP_OPEN_TABLE)
+      old_name()
   {}
 
   /**
@@ -97,14 +94,6 @@
   }
 
   /**
-   * @return the open method for this column.
-   */
-  uint32_t getOpenMethod() const
-  {
-    return open_method;
-  }
-
-  /**
    * @return the flags for this column.
    */
   uint32_t getFlags() const
@@ -174,12 +163,6 @@
    */
   const std::string old_name;
 
-  /**
-   * This should be one of @c SKIP_OPEN_TABLE,
-   * @c OPEN_FRM_ONLY or @c OPEN_FULL_TABLE.
-   */
-  uint32_t open_method;
-
 };
 
 /**
@@ -192,18 +175,72 @@
 public:
   virtual ~InfoSchemaMethods() {}
 
-  virtual Table *createSchemaTable(Session *session,
-                                   TableList *table_list) const;
   virtual int fillTable(Session *session, 
-                        TableList *tables,
-                        COND *cond);
-  virtual int processTable(Session *session, TableList *tables,
+                        TableList *tables);
+  virtual int processTable(InfoSchemaTable *store_table, 
+                           Session *session, TableList *tables,
                            Table *table, bool res, LEX_STRING *db_name,
-                           LEX_STRING *table_name) const;
+                           LEX_STRING *table_name);
   virtual int oldFormat(Session *session, 
                         InfoSchemaTable *schema_table) const;
 };
 
+class InfoSchemaRecord
+{
+public:
+  InfoSchemaRecord()
+    :
+      record(NULL),
+      rec_len(0)
+  {}
+
+  InfoSchemaRecord(unsigned char *buf,
+                   size_t in_len)
+    :
+      record(NULL),
+      rec_len(in_len)
+  {
+    record= new unsigned char[rec_len];
+    memcpy(record, buf, rec_len);
+  }
+
+  InfoSchemaRecord(const InfoSchemaRecord &rhs)
+    :
+      record(NULL),
+      rec_len(rhs.rec_len)
+  {
+    record= new unsigned char[rec_len];
+    memcpy(record, rhs.record, rec_len);
+  }
+
+  ~InfoSchemaRecord()
+  {
+    if (record)
+    {
+      delete [] record;
+    }
+  }
+
+  void copyRecordInto(unsigned char *buf)
+  {
+    memcpy(buf, record, rec_len);
+  }
+
+private:
+  unsigned char *record;
+  size_t rec_len;
+};
+
+class DeleteRows
+{
+public:
+  template<typename T>
+  inline void operator()(const T *ptr) const
+  {
+    delete ptr;
+  }
+};
+
 /**
  * @class InfoSchemaTable
  * @brief 
@@ -217,6 +254,7 @@
 public:
 
   typedef std::vector<const ColumnInfo *> Columns;
+  typedef std::vector<InfoSchemaRecord *> Rows;
   
   InfoSchemaTable(const std::string& tab_name,
                   Columns& in_column_info,
@@ -234,6 +272,7 @@
       second_column_index(idx_col2),
       requested_object(req_object),
       column_info(in_column_info),
+      rows(),
       i_s_methods(in_methods)
   {}
 
@@ -246,11 +285,17 @@
       second_column_index(0),
       requested_object(0),
       column_info(),
+      rows(),
       i_s_methods(NULL)
   {}
 
   virtual ~InfoSchemaTable()
-  {}
+  {
+    /* de-allocate memory in the rows */
+    for_each(rows.begin(),
+             rows.end(),
+             DeleteRows());
+  }
 
   /**
    * Set the methods available on this I_S table.
@@ -262,31 +307,15 @@
   }
 
   /**
-   * Create the temporary I_S tables using schema_table data.
-   *
-   * @param[in] session a session handler
-   * @param[in] table_list Used to pass I_S table information (fields,
-   *                       tables, parameters, etc.) and table name
-   * @retval \# pointer to created table
-   * @retval NULL Can't create table
-   */
-  Table *createSchemaTable(Session *session, TableList *table_list) const
-  {
-    Table *retval= i_s_methods->createSchemaTable(session, table_list);
-    return retval;
-  }
-
-  /**
    * Fill I_S table.
    *
    * @param[in] session a session handler
    * @param[in] tables I_S table
-   * @param[in] cond 'WHERE' condition
    * @return 0 on success; 1 on error
    */
-  int fillTable(Session *session, TableList *tables, COND *cond)
+  int fillTable(Session *session, TableList *tables)
   {
-    int retval= i_s_methods->fillTable(session, tables, cond);
+    int retval= i_s_methods->fillTable(session, tables);
     return retval;
   }
 
@@ -295,7 +324,6 @@
    *
    * @param[in] session a session handler
    * @param[in] tables table list (processed table)
-   * @param[in] table I_S table
    * @param[in] res 1 means error during opening of the processed table
    *                0 means processed table opened without error
    * @param[in] db_name database name
@@ -303,9 +331,9 @@
    * @return 0 on success; 1 on error
    */
   int processTable(Session *session, TableList *tables, Table *table,
-                   bool res, LEX_STRING *db_name, LEX_STRING *tab_name) const
+                   bool res, LEX_STRING *db_name, LEX_STRING *tab_name)
   {
-    int retval= i_s_methods->processTable(session, tables, table,
+    int retval= i_s_methods->processTable(this, session, tables, table,
                                           res, db_name, tab_name);
     return retval;
   }
@@ -410,6 +438,19 @@
     return column_info;
   }
 
+  Rows &getRows()
+  {
+    return rows;
+  }
+
+  void clearRows()
+  {
+    for_each(rows.begin(),
+             rows.end(),
+             DeleteRows());
+    rows.clear();
+  }
+
   /**
    * @param[in] index the index of this column
    * @return the name for the column at the given index
@@ -419,13 +460,10 @@
     return column_info[index]->getName();
   }
 
-  /**
-   * @param[in] index the index of this column
-   * @return the open method for the column at the given index
-   */
-  uint32_t getColumnOpenMethod(int index) const
+  void addRow(unsigned char *buf, size_t len)
   {
-    return column_info[index]->getOpenMethod();
+    InfoSchemaRecord *record= new InfoSchemaRecord(buf, len);
+    rows.push_back(record);
   }
 
 private:
@@ -464,6 +502,8 @@
    */
   Columns column_info;
 
+  Rows rows;
+
   /**
    * Contains the methods available on this I_S table.
    */
 
=== modified file 'drizzled/plugin/storage_engine.cc'
--- drizzled/plugin/storage_engine.cc	2009-10-19 04:52:19 +0000
+++ drizzled/plugin/storage_engine.cc	2009-10-29 23:56:14 +0000
@@ -137,7 +137,7 @@
     !0  Error
 */
 int plugin::StorageEngine::deleteTableImplementation(Session *,
-                                                     const string table_path)
+                                                     const string &table_path)
 {
   int error= 0;
   int enoent_or_zero= ENOENT;                   // Error if no file was deleted
@@ -757,16 +757,19 @@
 
     if (dirp == NULL)
     {
-      if (my_errno == ENOENT)
-        my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), db.c_str());
-      else
-        my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), path, my_errno);
-      return(ENOENT);
+      if (my_errno != ENOENT)
+      {
+        my_error(ER_CANT_READ_DIR, 
+                 MYF(ME_BELL + ME_WAITTANG), 
+                 path, 
+                 my_errno);
+      }
+      return ENOENT;
     }
     current_entry= -1;
   }
 
-  while(true)
+  while (true)
   {
     current_entry++;
 
@@ -844,7 +847,7 @@
 
   err= current_implementation->next(name);
 
-  if (err == -1)
+  if (err == -1 || err == ENOENT)
   {
     if (current_implementation != default_implementation)
     {
@@ -852,6 +855,19 @@
       current_implementation= NULL;
       goto next;
     }
+    if (current_implementation == default_implementation)
+    {
+      if (database.compare(INFORMATION_SCHEMA_NAME) == 0)
+      {
+        return -1;
+      }
+      if (err == ENOENT)
+      {
+        my_error(ER_BAD_DB_ERROR,
+                 MYF(ME_BELL + ME_WAITTANG),
+                 database.c_str());
+      }
+    }
   }
 
   return err;
 
=== modified file 'drizzled/plugin/storage_engine.h'
--- drizzled/plugin/storage_engine.h	2009-10-16 10:27:33 +0000
+++ drizzled/plugin/storage_engine.h	2009-10-29 23:56:14 +0000
@@ -54,6 +54,7 @@
   HTON_BIT_TEMPORARY_ONLY,
   HTON_BIT_FILE_BASED, // use for check_lowercase_names
   HTON_BIT_HAS_DATA_DICTIONARY,
+  HTON_BIT_CREATE_NOT_SUPPORTED, // Engine does support the creation of tables
   HTON_BIT_SIZE
 };
 
@@ -67,6 +68,7 @@
 static const std::bitset<HTON_BIT_SIZE> HTON_TEMPORARY_ONLY(1 << HTON_BIT_TEMPORARY_ONLY);
 static const std::bitset<HTON_BIT_SIZE> HTON_FILE_BASED(1 << HTON_BIT_FILE_BASED);
 static const std::bitset<HTON_BIT_SIZE> HTON_HAS_DATA_DICTIONARY(1 << HTON_BIT_HAS_DATA_DICTIONARY);
+static const std::bitset<HTON_BIT_SIZE> HTON_CREATE_NOT_SUPPORTED(1 << HTON_BIT_CREATE_NOT_SUPPORTED);
 
 class Table;
 
@@ -276,7 +278,7 @@
                                         const char *from, const char *to);
 
   virtual int deleteTableImplementation(Session* session,
-                                        const std::string table_path);
+                                        const std::string &table_path);
 
 public:
   int doCreateTable(Session *session, const char *path, 
 
=== modified file 'drizzled/show.cc'
--- drizzled/show.cc	2009-10-16 00:38:56 +0000
+++ drizzled/show.cc	2009-10-29 23:56:14 +0000
@@ -63,8 +63,6 @@
 
 static void store_key_options(String *packet, Table *table, KEY *key_info);
 
-
-
 int wild_case_compare(const CHARSET_INFO * const cs, const char *str,const char *wildstr)
 {
   register int flag;
@@ -225,9 +223,6 @@
   if (session->client->sendFields(&field_list))
     return true;
   {
-    if (table_list->schema_table)
-      session->client->store(table_list->schema_table->getTableName().c_str());
-    else
       session->client->store(table_list->table->alias);
   }
 
@@ -1016,35 +1011,6 @@
   return;
 }
 
-/*
-  Store record to I_S table, convert HEAP table
-  to MyISAM if necessary
-
-  SYNOPSIS
-    schema_table_store_record()
-    session                   thread Cursor
-    table                 Information schema table to be updated
-
-  RETURN
-    0	                  success
-    1	                  error
-*/
-
-bool schema_table_store_record(Session *session, Table *table)
-{
-  int error;
-  if ((error= table->file->ha_write_row(table->record[0])))
-  {
-    Tmp_Table_Param *param= table->pos_in_table_list->schema_table_param;
-
-    if (create_myisam_from_heap(session, table, param->start_recinfo,
-                                &param->recinfo, error, 0))
-      return true;
-  }
-  return false;
-}
-
-
 static int make_table_list(Session *session, Select_Lex *sel,
                            LEX_STRING *db_name, LEX_STRING *table_name)
 {
@@ -1484,14 +1450,6 @@
     return 0;
   }
 
-  /*
-    This call will add all matching the wildcards (if specified) IS tables
-    to the list
-  */
-  if (with_i_schema)
-    return plugin::InfoSchemaTable::addTableToList(session, table_names,
-                                      lookup_field_vals->table_value.str);
-
   string db(db_name->str);
 
   plugin::TableNameIterator tniter(db);
@@ -1593,13 +1551,16 @@
 
 
    table->setWriteSet();
-   error= test(schema_table->processTable(session, show_table_list,
-                                          table, res, db_name,
+   error= test(schema_table->processTable(session,
+                                          show_table_list,
+                                          table, 
+                                          res, 
+                                          db_name,
                                           table_name));
    session->temporary_tables= 0;
    session->close_tables_for_reopen(&show_table_list);
 
-   return(error);
+   return error;
 }
 
 
@@ -1641,114 +1602,13 @@
       return 0;
     }
   }
-  if (schema_table_store_record(session, table))
-    return 1;
+  TableList *tmp= table->pos_in_table_list;
+  tmp->schema_table->addRow(table->record[0], table->s->reclength);
   return 0;
 }
 
 
 /**
-  @brief          Get open table method
-
-  @details        The function calculates the method which will be used
-                  for table opening:
-                  SKIP_OPEN_TABLE - do not open table
-                  OPEN_FRM_ONLY   - open FRM file only
-                  OPEN_FULL_TABLE - open FRM, data, index files
-  @param[in]      tables               I_S table table_list
-  @param[in]      schema_table         I_S table struct
-
-  @return         return a set of flags
-    @retval       SKIP_OPEN_TABLE | OPEN_FRM_ONLY | OPEN_FULL_TABLE
-*/
-
-static uint32_t get_table_open_method(TableList *tables,
-                                      plugin::InfoSchemaTable *schema_table)
-{
-  /*
-    determine which method will be used for table opening
-  */
-  if (schema_table->getRequestedObject() & OPTIMIZE_I_S_TABLE)
-  {
-    Field **ptr, *field;
-    int table_open_method= 0, field_indx= 0;
-    for (ptr= tables->table->field; (field= *ptr) ; ptr++)
-    {
-      if (field->isReadSet())
-        table_open_method|= schema_table->getColumnOpenMethod(field_indx);
-      field_indx++;
-    }
-    return table_open_method;
-  }
-  /* I_S tables which use get_all_tables but can not be optimized */
-  return (uint32_t) OPEN_FULL_TABLE;
-}
-
-
-/**
-  @brief          Fill I_S table with data from FRM file only
-
-  @param[in]      session                      thread Cursor
-  @param[in]      table                    Table struct for I_S table
-  @param[in]      schema_table             I_S table struct
-  @param[in]      db_name                  database name
-  @param[in]      table_name               table name
-
-  @return         Operation status
-    @retval       0           Table is processed and we can continue
-                              with new table
-    @retval       1           It's view and we have to use
-                              open_tables function for this table
-*/
-
-static int fill_schema_table_from_frm(Session *session,TableList *tables,
-                                      plugin::InfoSchemaTable *schema_table,
-                                      LEX_STRING *db_name,
-                                      LEX_STRING *table_name)
-{
-  Table *table= tables->table;
-  TableShare *share;
-  Table tbl;
-  TableList table_list;
-  uint32_t res= 0;
-  int error;
-  char key[MAX_DBKEY_LENGTH];
-  uint32_t key_length;
-
-  memset(&tbl, 0, sizeof(Table));
-
-  table_list.table_name= table_name->str;
-  table_list.db= db_name->str;
-
-  key_length= table_list.create_table_def_key(key);
-  pthread_mutex_lock(&LOCK_open); /* Locking to get table share when filling schema table from FRM */
-  share= TableShare::getShare(session, &table_list, key, key_length, 0, &error);
-  if (!share)
-  {
-    res= 0;
-    goto err;
-  }
-
-  {
-    tbl.s= share;
-    table_list.table= &tbl;
-    res= schema_table->processTable(session, &table_list, table,
-                                    res, db_name, table_name);
-  }
-  /* For the moment we just set everything to read */
-  table->setReadSet();
-
-  TableShare::release(share);
-
-err:
-  pthread_mutex_unlock(&LOCK_open);
-  session->clear_error();
-  return res;
-}
-
-
-
-/**
   @brief          Fill I_S tables whose data are retrieved
                   from frm files and storage engine
 
@@ -1760,13 +1620,12 @@
 
   @param[in]      session                      thread Cursor
   @param[in]      tables                   I_S table
-  @param[in]      cond                     'WHERE' condition
 
   @return         Operation status
     @retval       0                        success
     @retval       1                        error
 */
-int plugin::InfoSchemaMethods::fillTable(Session *session, TableList *tables, COND *cond)
+int plugin::InfoSchemaMethods::fillTable(Session *session, TableList *tables)
 {
   LEX *lex= session->lex;
   Table *table= tables->table;
@@ -1779,11 +1638,12 @@
   bool with_i_schema;
   vector<LEX_STRING*> db_names, table_names;
   COND *partial_cond= 0;
+  /* the WHERE condition */
+  COND *cond= table->reginfo.join_tab->select_cond;
   uint32_t derived_tables= lex->derived_tables;
   int error= 1;
   Open_tables_state open_tables_state_backup;
   Query_tables_list query_tables_list_backup;
-  uint32_t table_open_method;
   bool old_value= session->no_warnings_for_error;
 
   /*
@@ -1793,8 +1653,6 @@
   */
   session->reset_n_backup_open_tables_state(&open_tables_state_backup);
 
-  tables->table_open_method= table_open_method=
-    get_table_open_method(tables, schema_table);
   /*
     this branch processes SHOW FIELDS, SHOW INDEXES commands.
     see sql_parse.cc, prepare_schema_table() function where
@@ -1813,14 +1671,14 @@
     goto err;
   }
 
-  if (!lookup_field_vals.wild_db_value && !lookup_field_vals.wild_table_value)
+  if (! lookup_field_vals.wild_db_value && ! lookup_field_vals.wild_table_value)
   {
     /*
       if lookup value is empty string then
       it's impossible table name or db name
     */
-    if ((lookup_field_vals.db_value.str && !lookup_field_vals.db_value.str[0]) ||
-        (lookup_field_vals.table_value.str && !lookup_field_vals.table_value.str[0]))
+    if ((lookup_field_vals.db_value.str && ! lookup_field_vals.db_value.str[0]) ||
+        (lookup_field_vals.table_value.str && ! lookup_field_vals.table_value.str[0]))
     {
       error= 0;
       goto err;
@@ -1828,12 +1686,16 @@
   }
 
   if (lookup_field_vals.db_value.length &&
-      !lookup_field_vals.wild_db_value)
+      ! lookup_field_vals.wild_db_value)
+  {
     tables->has_db_lookup_value= true;
+  }
 
   if (lookup_field_vals.table_value.length &&
-      !lookup_field_vals.wild_table_value)
+      ! lookup_field_vals.wild_table_value)
+  {
     tables->has_table_lookup_value= true;
+  }
 
   if (tables->has_db_lookup_value && tables->has_table_lookup_value)
     partial_cond= 0;
@@ -1874,55 +1736,36 @@
       table->field[schema_table->getSecondColumnIndex()]->
         store((*table_name)->str, (*table_name)->length, system_charset_info);
 
-      if (!partial_cond || partial_cond->val_int())
+      if (! partial_cond || partial_cond->val_int())
       {
-        /*
-          If table is I_S.tables and open_table_method is 0 (eg SKIP_OPEN)
-          we can skip table opening and we don't have lookup value for
-          table name or lookup value is wild string(table name list is
-          already created by make_table_name_list() function).
-        */
-        if (! table_open_method &&
-            schema_table->getTableName().compare("TABLES") == 0 &&
-            (! lookup_field_vals.table_value.length ||
-             lookup_field_vals.wild_table_value))
-        {
-          if (schema_table_store_record(session, table))
-            goto err;      /* Out of space in temporary table */
-          continue;
-        }
-
-        /* SHOW Table NAMES command */
         if (schema_table->getTableName().compare("TABLE_NAMES") == 0)
         {
-          if (fill_schema_table_names(session, tables->table, *db_name,
-                                      *table_name, with_i_schema))
+          if (fill_schema_table_names(session,
+                                      tables->table,
+                                      *db_name,
+                                      *table_name,
+                                      with_i_schema))
+          {
             continue;
+          }
         }
         else
         {
-          if (!(table_open_method & ~OPEN_FRM_ONLY) &&
-              !with_i_schema)
-          {
-            if (!fill_schema_table_from_frm(session, tables, schema_table, *db_name,
-                                            *table_name))
-              continue;
-          }
-
           LEX_STRING tmp_lex_string, orig_db_name;
-          /*
-            Set the parent lex of 'sel' because it is needed by
-            sel.init_query() which is called inside make_table_list.
-          */
           session->no_warnings_for_error= 1;
           sel.parent_lex= lex;
-          /* db_name can be changed in make_table_list() func */
-          if (!session->make_lex_string(&orig_db_name, (*db_name)->str,
-                                        (*db_name)->length, false))
+          if (! session->make_lex_string(&orig_db_name,
+                (*db_name)->str,
+                (*db_name)->length,
+                false))
+          {
             goto err;
+          }
 
           if (make_table_list(session, &sel, *db_name, *table_name))
+          {
             goto err;
+          }
 
           TableList *show_table_list= (TableList*) sel.table_list.first;
           lex->all_selects_list= &sel;
@@ -1933,38 +1776,41 @@
           res= session->openTables(show_table_list, DRIZZLE_LOCK_IGNORE_FLUSH);
           lex->sql_command= save_sql_command;
           /*
-            XXX->  show_table_list has a flag i_is_requested,
-            and when it's set, openTables()
-            can return an error without setting an error message
-            in Session, which is a hack. This is why we have to
-            check for res, then for session->is_error() only then
-            for session->main_da.sql_errno().
-          */
+             XXX->  show_table_list has a flag i_is_requested,
+             and when it's set, openTables()
+             can return an error without setting an error message
+             in Session, which is a hack. This is why we have to
+             check for res, then for session->is_error() only then
+             for session->main_da.sql_errno().
+           */
           if (res && session->is_error() &&
               session->main_da.sql_errno() == ER_NO_SUCH_TABLE)
           {
             /*
-              Hide error for not existing table.
-              This error can occur for example when we use
-              where condition with db name and table name and this
-              table does not exist.
-            */
+               Hide error for not existing table.
+               This error can occur for example when we use
+               where condition with db name and table name and this
+               table does not exist.
+             */
             res= 0;
             session->clear_error();
           }
           else
           {
             /*
-              We should use show_table_list->alias instead of
-              show_table_list->table_name because table_name
-              could be changed during opening of I_S tables. It's safe
-              to use alias because alias contains original table name
-              in this case.
-            */
+               We should use show_table_list->alias instead of
+               show_table_list->table_name because table_name
+               could be changed during opening of I_S tables. It's safe
+               to use alias because alias contains original table name
+               in this case.
+             */
             session->make_lex_string(&tmp_lex_string, show_table_list->alias,
-                                     strlen(show_table_list->alias), false);
-            res= schema_table->processTable(session, show_table_list, table,
-                                            res, &orig_db_name,
+                strlen(show_table_list->alias), false);
+            res= schema_table->processTable(session,
+                                            show_table_list, 
+                                            table,
+                                            res, 
+                                            &orig_db_name,
                                             &tmp_lex_string);
             session->close_tables_for_reopen(&show_table_list);
           }
@@ -2092,10 +1938,12 @@
 }
 
 
-int plugin::InfoSchemaMethods::processTable(Session *session, TableList *tables,
+int plugin::InfoSchemaMethods::processTable(
+            plugin::InfoSchemaTable *store_table,
+            Session *session, TableList *tables,
 				    Table *table, bool res,
 				    LEX_STRING *db_name,
-				    LEX_STRING *table_name) const
+				    LEX_STRING *table_name)
 {
   LEX *lex= session->lex;
   const char *wild= lex->wild ? lex->wild->ptr() : NULL;
@@ -2119,7 +1967,7 @@
       session->clear_error();
       res= 0;
     }
-    return(res);
+    return res;
   }
 
   show_table= tables->table;
@@ -2138,7 +1986,7 @@
   }
 
   /* For the moment we just set everything to read */
-  if (!show_table->read_set)
+  if (! show_table->read_set)
   {
     show_table->def_read_set.setAll();
     show_table->read_set= &show_table->def_read_set;
@@ -2206,109 +2054,9 @@
       table->field[20]->store((const char*) pos,
                               strlen((const char*) pos), cs);
     }
-    if (schema_table_store_record(session, table))
-      return(1);
-  }
-  return(0);
-}
-
-
-Table *plugin::InfoSchemaMethods::createSchemaTable(Session *session, TableList *table_list)
-  const
-{
-  int field_count= 0;
-  Item *item;
-  Table *table;
-  List<Item> field_list;
-  const CHARSET_INFO * const cs= system_charset_info;
-  const plugin::InfoSchemaTable::Columns &columns= table_list->schema_table->getColumns();
-  plugin::InfoSchemaTable::Columns::const_iterator iter= columns.begin();
-
-  while (iter != columns.end())
-  {
-    const plugin::ColumnInfo *column= *iter;
-    switch (column->getType()) {
-    case DRIZZLE_TYPE_LONG:
-    case DRIZZLE_TYPE_LONGLONG:
-      if (!(item= new Item_return_int(column->getName().c_str(),
-                                      column->getLength(),
-                                      column->getType(),
-                                      column->getValue())))
-      {
-        return(0);
-      }
-      item->unsigned_flag= (column->getFlags() & MY_I_S_UNSIGNED);
-      break;
-    case DRIZZLE_TYPE_DATE:
-    case DRIZZLE_TYPE_TIMESTAMP:
-    case DRIZZLE_TYPE_DATETIME:
-      if (!(item=new Item_return_date_time(column->getName().c_str(),
-                                           column->getType())))
-      {
-        return(0);
-      }
-      break;
-    case DRIZZLE_TYPE_DOUBLE:
-      if ((item= new Item_float(column->getName().c_str(), 0.0, NOT_FIXED_DEC,
-                           column->getLength())) == NULL)
-        return NULL;
-      break;
-    case DRIZZLE_TYPE_NEWDECIMAL:
-      if (!(item= new Item_decimal((int64_t) column->getValue(), false)))
-      {
-        return(0);
-      }
-      item->unsigned_flag= (column->getFlags() & MY_I_S_UNSIGNED);
-      item->decimals= column->getLength() % 10;
-      item->max_length= (column->getLength()/100)%100;
-      if (item->unsigned_flag == 0)
-        item->max_length+= 1;
-      if (item->decimals > 0)
-        item->max_length+= 1;
-      item->set_name(column->getName().c_str(),
-                     column->getName().length(), cs);
-      break;
-    case DRIZZLE_TYPE_BLOB:
-      if (!(item= new Item_blob(column->getName().c_str(),
-                                column->getLength())))
-      {
-        return(0);
-      }
-      break;
-    default:
-      if (!(item= new Item_empty_string("", column->getLength(), cs)))
-      {
-        return(0);
-      }
-      item->set_name(column->getName().c_str(),
-                     column->getName().length(), cs);
-      break;
-    }
-    field_list.push_back(item);
-    item->maybe_null= (column->getFlags() & MY_I_S_MAYBE_NULL);
-    field_count++;
-    ++iter;
-  }
-  Tmp_Table_Param *tmp_table_param =
-    (Tmp_Table_Param*) (session->alloc(sizeof(Tmp_Table_Param)));
-  tmp_table_param->init();
-  tmp_table_param->table_charset= cs;
-  tmp_table_param->field_count= field_count;
-  tmp_table_param->schema_table= 1;
-  Select_Lex *select_lex= session->lex->current_select;
-  if (!(table= create_tmp_table(session, tmp_table_param,
-                                field_list, (order_st*) 0, 0, 0,
-                                (select_lex->options | session->options |
-                                 TMP_TABLE_ALL_COLUMNS),
-                                HA_POS_ERROR, table_list->alias)))
-    return(0);
-  my_bitmap_map* bitmaps=
-    (my_bitmap_map*) session->alloc(bitmap_buffer_size(field_count));
-  table->def_read_set.init((my_bitmap_map*) bitmaps, field_count);
-  table->read_set= &table->def_read_set;
-  table->read_set->clearAll();
-  table_list->schema_table_param= tmp_table_param;
-  return(table);
+    store_table->addRow(table->record[0], table->s->reclength);
+  }
+  return 0;
 }
 
 
@@ -2358,47 +2106,6 @@
 
 
 /*
-  Create information_schema table
-
-  SYNOPSIS
-  mysql_schema_table()
-    session                thread Cursor
-    lex                pointer to LEX
-    table_list         pointer to table_list
-
-  RETURN
-    true on error
-*/
-
-bool mysql_schema_table(Session *session, LEX *, TableList *table_list)
-{
-  Table *table;
-  if (!(table= table_list->schema_table->createSchemaTable(session, table_list)))
-    return true;
-  table->s->tmp_table= SYSTEM_TMP_TABLE;
-  /*
-    This test is necessary to make
-    case insensitive file systems +
-    upper case table names(information schema tables) +
-    views
-    working correctly
-  */
-  if (table_list->schema_table_name)
-    table->alias_name_used= my_strcasecmp(table_alias_charset,
-                                          table_list->schema_table_name,
-                                          table_list->alias);
-  table_list->table_name= table->s->table_name.str;
-  table_list->table_name_length= table->s->table_name.length;
-  table_list->table= table;
-  table->next= session->derived_tables;
-  session->derived_tables= table;
-  table_list->select_lex->options |= OPTION_SCHEMA_TABLE;
-
-  return false;
-}
-
-
-/*
   Generate select from information_schema table
 
   SYNOPSIS
@@ -2432,91 +2139,3 @@
   return false;
 }
 
-
-/*
-  Fill temporary schema tables before SELECT
-
-  SYNOPSIS
-    get_schema_tables_result()
-    join  join which use schema tables
-    executed_place place where I_S table processed
-
-  RETURN
-    false success
-    true  error
-*/
-
-bool get_schema_tables_result(JOIN *join,
-                              enum enum_schema_table_state executed_place)
-{
-  JoinTable *tmp_join_tab= join->join_tab+join->tables;
-  Session *session= join->session;
-  LEX *lex= session->lex;
-  bool result= 0;
-
-  session->no_warnings_for_error= 1;
-  for (JoinTable *tab= join->join_tab; tab < tmp_join_tab; tab++)
-  {
-    if (!tab->table || !tab->table->pos_in_table_list)
-      break;
-
-    TableList *table_list= tab->table->pos_in_table_list;
-    if (table_list->schema_table)
-    {
-      bool is_subselect= (&lex->unit != lex->current_select->master_unit() &&
-                          lex->current_select->master_unit()->item);
-
-
-      /* skip I_S optimizations specific to get_all_tables */
-      if (session->lex->describe &&
-          (table_list->schema_table->isOptimizationPossible() != true))
-      {
-        continue;
-      }
-
-      /*
-        If schema table is already processed and
-        the statement is not a subselect then
-        we don't need to fill this table again.
-        If schema table is already processed and
-        schema_table_state != executed_place then
-        table is already processed and
-        we should skip second data processing.
-      */
-      if (table_list->schema_table_state &&
-          (!is_subselect || table_list->schema_table_state != executed_place))
-        continue;
-
-      /*
-        if table is used in a subselect and
-        table has been processed earlier with the same
-        'executed_place' value then we should refresh the table.
-      */
-      if (table_list->schema_table_state && is_subselect)
-      {
-        table_list->table->file->extra(HA_EXTRA_NO_CACHE);
-        table_list->table->file->extra(HA_EXTRA_RESET_STATE);
-        table_list->table->file->ha_delete_all_rows();
-        table_list->table->free_io_cache();
-        table_list->table->filesort_free_buffers(true);
-        table_list->table->null_row= 0;
-      }
-      else
-        table_list->table->file->stats.records= 0;
-
-      if (table_list->schema_table->fillTable(session, table_list,
-                                               tab->select_cond))
-      {
-        result= 1;
-        join->error= 1;
-        tab->read_record.file= table_list->table->file;
-        table_list->schema_table_state= executed_place;
-        break;
-      }
-      tab->read_record.file= table_list->table->file;
-      table_list->schema_table_state= executed_place;
-    }
-  }
-  session->no_warnings_for_error= 0;
-  return(result);
-}
 
=== modified file 'drizzled/show.h'
--- drizzled/show.h	2009-09-29 22:52:00 +0000
+++ drizzled/show.h	2009-10-29 23:56:14 +0000
@@ -70,16 +70,12 @@
 
 int store_create_info(TableList *table_list, String *packet, HA_CREATE_INFO  *create_info_arg);
 
-bool schema_table_store_record(Session *session, Table *table);
-
 int get_quote_char_for_identifier();
 int wild_case_compare(const CHARSET_INFO * const cs, 
                       const char *str,const char *wildstr);
 
 bool make_schema_select(Session *session,  Select_Lex *sel,
                         const std::string& schema_table_name);
-bool mysql_schema_table(Session *session, LEX *lex, TableList *table_list);
-bool get_schema_tables_result(JOIN *join, enum enum_schema_table_state executed_place);
 
 bool mysqld_show_open_tables(Session *session,const char *wild);
 bool mysqld_show_logs(Session *session);
 
=== modified file 'drizzled/sql_base.cc'
--- drizzled/sql_base.cc	2009-10-16 10:27:33 +0000
+++ drizzled/sql_base.cc	2009-10-29 23:56:14 +0000
@@ -2139,18 +2139,6 @@
     {
       continue;
     }
-    /*
-      If this TableList object is a placeholder for an information_schema
-      table, create a temporary table to represent the information_schema
-      table in the query. Do not fill it yet - will be filled during
-      execution.
-    */
-    if (tables->schema_table)
-    {
-      if (mysql_schema_table(this, lex, tables) == false)
-        continue;
-      return -1;
-    }
     (*counter)++;
 
     /*
 
=== modified file 'drizzled/sql_select.cc'
--- drizzled/sql_select.cc	2009-10-16 10:27:33 +0000
+++ drizzled/sql_select.cc	2009-10-29 23:56:14 +0000
@@ -5294,11 +5294,6 @@
     }
   }
 
-  /* Fill schema tables with data before filesort if it's necessary */
-  if ((join->select_lex->options & OPTION_SCHEMA_TABLE) &&
-      get_schema_tables_result(join, PROCESSED_BY_CREATE_SORT_INDEX))
-    goto err;
-
   if (table->s->tmp_table)
     table->file->info(HA_STATUS_VARIABLE);	// Get record count
   table->sort.found_records=filesort(session, table,join->sortorder, length,
@@ -6935,12 +6930,6 @@
         if (table_list->schema_table &&
             table_list->schema_table->getRequestedObject() & OPTIMIZE_I_S_TABLE)
         {
-          if (!table_list->table_open_method)
-            extra.append(STRING_WITH_LEN("; Skip_open_table"));
-          else if (table_list->table_open_method == OPEN_FRM_ONLY)
-            extra.append(STRING_WITH_LEN("; Open_frm_only"));
-          else
-            extra.append(STRING_WITH_LEN("; Open_full_table"));
           if (table_list->has_db_lookup_value &&
               table_list->has_table_lookup_value)
             extra.append(STRING_WITH_LEN("; Scanned 0 databases"));
 
=== modified file 'drizzled/sql_table.cc'
--- drizzled/sql_table.cc	2009-10-19 19:19:38 +0000
+++ drizzled/sql_table.cc	2009-10-29 23:56:14 +0000
@@ -385,18 +385,12 @@
 {
   bool error, need_start_waiting= false;
 
-  if (tables && tables->schema_table)
-  {
-    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0), "", "", INFORMATION_SCHEMA_NAME.c_str());
-    return(true);
-  }
-
   /* mark for close and remove all cached entries */
 
-  if (!drop_temporary)
+  if (! drop_temporary)
   {
-    if (!(need_start_waiting= !wait_if_global_read_lock(session, 0, 1)))
-      return(true);
+    if (! (need_start_waiting= ! wait_if_global_read_lock(session, 0, 1)))
+      return true;
   }
 
   /*
@@ -2437,19 +2431,7 @@
   pthread_mutex_lock(&LOCK_open); /* We lock for CREATE TABLE LIKE to copy table definition */
   {
     int protoerr= EEXIST;
-
-    if (src_table->schema_table)
-    {
-      if (create_like_schema_frm(session, src_table, create_info, &src_proto))
-      {
-        pthread_mutex_unlock(&LOCK_open);
-        goto err;
-      }
-    }
-    else
-    {
-      protoerr= plugin::StorageEngine::getTableProto(src_path, &src_proto);
-    }
+    protoerr= plugin::StorageEngine::getTableProto(src_path, &src_proto);
 
     message::Table new_proto(src_proto);
 
 
=== modified file 'drizzled/table.cc'
--- drizzled/table.cc	2009-10-20 16:11:52 +0000
+++ drizzled/table.cc	2009-10-29 23:56:14 +0000
@@ -283,6 +283,12 @@
 
   share->storage_engine= plugin::StorageEngine::findByName(session, table.engine().name());
 
+  if (! share->storage_engine)
+  {
+    share->storage_engine= plugin::StorageEngine::findByName(session,
+                                                             table.engine().name());
+  }
+
   message::Table::TableOptions table_options;
 
   if (table.has_options())
 
=== modified file 'drizzled/table_list.h'
--- drizzled/table_list.h	2009-10-20 16:11:52 +0000
+++ drizzled/table_list.h	2009-10-29 23:56:14 +0000
@@ -126,9 +126,8 @@
     is_alias(false),
     is_fqtn(false),
     has_db_lookup_value(false),
-    has_table_lookup_value(false),
-    table_open_method(0)
-  {}
+    has_table_lookup_value(false)
+    {}
 
   /**
    * List of tables local to a subquery (used by SQL_LIST). Considers
@@ -246,7 +245,6 @@
 
   bool has_db_lookup_value;
   bool has_table_lookup_value;
-  uint32_t table_open_method;
   enum enum_schema_table_state schema_table_state;
 
   void set_underlying_merge();
 
=== modified file 'plugin/archive/ha_archive.cc'
--- plugin/archive/ha_archive.cc	2009-10-19 04:52:19 +0000
+++ plugin/archive/ha_archive.cc	2009-10-29 23:56:14 +0000
@@ -174,11 +174,9 @@
     dirp = my_dir(path,MYF(dir ? MY_WANT_STAT : 0));
     if (dirp == NULL)
     {
-      if (my_errno == ENOENT)
-        my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), db.c_str());
-      else
+      if (my_errno != ENOENT)
         my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), path, my_errno);
-      return(ENOENT);
+      return ENOENT;
     }
     current_entry= -1;
   }
 
=== modified file 'plugin/blackhole/ha_blackhole.cc'
--- plugin/blackhole/ha_blackhole.cc	2009-10-16 01:56:08 +0000
+++ plugin/blackhole/ha_blackhole.cc	2009-10-29 23:56:14 +0000
@@ -46,7 +46,7 @@
   int createTableImplementation(Session*, const char *, Table *,
                                 HA_CREATE_INFO *, drizzled::message::Table*);
 
-  int deleteTableImplementation(Session*, const string table_name); 
+  int deleteTableImplementation(Session*, const string &table_name); 
 };
 
 /* Static declarations for shared structures */
@@ -105,7 +105,7 @@
   return(0);
 }
 
-int BlackholeEngine::deleteTableImplementation(Session*, const string path)
+int BlackholeEngine::deleteTableImplementation(Session*, const string &path)
 {
   if (unlink(path.c_str()) != 0)
   {
 
=== modified file 'plugin/heap/ha_heap.cc'
--- plugin/heap/ha_heap.cc	2009-10-16 10:27:33 +0000
+++ plugin/heap/ha_heap.cc	2009-10-29 23:56:14 +0000
@@ -72,14 +72,14 @@
 
   int renameTableImplementation(Session*, const char * from, const char * to);
 
-  int deleteTableImplementation(Session *, const string table_path);
+  int deleteTableImplementation(Session *, const string &table_path);
 };
 
 /*
   We have to ignore ENOENT entries as the HEAP table is created on open and
   not when doing a CREATE on the table.
 */
-int HeapEngine::deleteTableImplementation(Session*, const string table_path)
+int HeapEngine::deleteTableImplementation(Session*, const string &table_path)
 {
   return heap_delete_table(table_path.c_str());
 }
 
=== modified file 'plugin/info_schema/info_schema_columns.cc'
--- plugin/info_schema/info_schema_columns.cc	2009-09-22 17:56:50 +0000
+++ plugin/info_schema/info_schema_columns.cc	2009-10-29 23:56:14 +0000
@@ -44,8 +44,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "Charset",
-                                                           SKIP_OPEN_TABLE);
+                                                           "Charset");
   if (name_col == NULL)
   {
     return true;
@@ -56,8 +55,7 @@
                                                               DRIZZLE_TYPE_VARCHAR,
                                                               0,
                                                               0,
-                                                              "Default collation",
-                                                              SKIP_OPEN_TABLE);
+                                                              "Default collation");
   if (collate_col == NULL)
   {
     return true;
@@ -68,8 +66,7 @@
                                                               DRIZZLE_TYPE_VARCHAR,
                                                               0,
                                                               0,
-                                                              "Description",
-                                                              SKIP_OPEN_TABLE);
+                                                              "Description");
   if (descrip_col == NULL)
   {
     return true;
@@ -80,8 +77,7 @@
                                                           DRIZZLE_TYPE_LONGLONG,
                                                           0,
                                                           0,
-                                                          "Maxlen",
-                                                          SKIP_OPEN_TABLE);
+                                                          "Maxlen");
   if (len_col == NULL)
   {
     return true;
@@ -108,8 +104,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "Collation",
-                                                           SKIP_OPEN_TABLE);
+                                                           "Collation");
   if (name_col == NULL)
   {
     return true;
@@ -120,8 +115,7 @@
                                                                DRIZZLE_TYPE_VARCHAR,
                                                                0,
                                                                0,
-                                                               "Default collation",
-                                                               SKIP_OPEN_TABLE);
+                                                               "Default collation");
   if (char_set_col == NULL)
   {
     return true;
@@ -132,8 +126,7 @@
                                                               DRIZZLE_TYPE_VARCHAR,
                                                               0,
                                                               0,
-                                                              "Charset",
-                                                              SKIP_OPEN_TABLE);
+                                                              "Charset");
   if (descrip_col == NULL)
   {
     return true;
@@ -144,8 +137,7 @@
                                                          DRIZZLE_TYPE_LONGLONG,
                                                          0,
                                                          0,
-                                                         "Id",
-                                                         SKIP_OPEN_TABLE);
+                                                         "Id");
   if (id_col == NULL)
   {
     return true;
@@ -156,8 +148,7 @@
                                                               DRIZZLE_TYPE_VARCHAR,
                                                               0,
                                                               0,
-                                                              "Default",
-                                                              SKIP_OPEN_TABLE);
+                                                              "Default");
   if (default_col == NULL)
   {
     return true;
@@ -168,8 +159,7 @@
                                                                DRIZZLE_TYPE_VARCHAR,
                                                                0,
                                                                0,
-                                                               "Compiled",
-                                                               SKIP_OPEN_TABLE);
+                                                               "Compiled");
   if (compiled_col == NULL)
   {
     return true;
@@ -180,8 +170,7 @@
                                                               DRIZZLE_TYPE_LONGLONG,
                                                               0,
                                                               0,
-                                                              "Sortlen",
-                                                              SKIP_OPEN_TABLE);
+                                                              "Sortlen");
   if (sortlen_col == NULL)
   {
     return true;
@@ -211,8 +200,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "",
-                                                           SKIP_OPEN_TABLE);
+                                                           "");
   if (name_col == NULL)
   {
     return true;
@@ -223,8 +211,7 @@
                                                                DRIZZLE_TYPE_VARCHAR,
                                                                0,
                                                                0,
-                                                               "",
-                                                               SKIP_OPEN_TABLE);
+                                                               "");
   if (char_set_col == NULL)
   {
     return true;
@@ -249,8 +236,7 @@
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           1,
-                                                          "",
-                                                          OPEN_FRM_ONLY);
+                                                          "");
   if (tab_cat == NULL)
   {
     return true;
@@ -261,8 +247,7 @@
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           0,
-                                                          "",
-                                                          OPEN_FRM_ONLY);
+                                                          "");
   if (tab_sch == NULL)
   {
     return true;
@@ -273,8 +258,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "",
-                                                           OPEN_FRM_ONLY);
+                                                           "");
   if (tab_name == NULL)
   {
     return true;
@@ -285,8 +269,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "Field",
-                                                           OPEN_FRM_ONLY);
+                                                           "Field");
   if (col_name == NULL)
   {
     return true;
@@ -297,20 +280,19 @@
                                                           DRIZZLE_TYPE_LONGLONG,
                                                           0,
                                                           MY_I_S_UNSIGNED,
-                                                          "",
-                                                          OPEN_FRM_ONLY);
+                                                          "");
   if (ord_pos == NULL)
   {
     return true;
   }
 
   const drizzled::plugin::ColumnInfo *col_def= new(std::nothrow) drizzled::plugin::ColumnInfo("COLUMN_DEFAULT",
-                                                          MAX_FIELD_VARCHARLENGTH,
+                                                          64,
+                                                          //MAX_FIELD_VARCHARLENGTH,
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           1,
-                                                          "Default",
-                                                          OPEN_FRM_ONLY);
+                                                          "Default");
   if (col_def == NULL)
   {
     return true;
@@ -321,8 +303,7 @@
                                                               DRIZZLE_TYPE_VARCHAR,
                                                               0,
                                                               0,
-                                                              "Null",
-                                                              OPEN_FRM_ONLY);
+                                                              "Null");
   if (is_nullable == NULL)
   {
     return true;
@@ -333,8 +314,7 @@
                                                             DRIZZLE_TYPE_VARCHAR,
                                                             0,
                                                             0,
-                                                            "",
-                                                            OPEN_FRM_ONLY);
+                                                            "");
   if (data_type == NULL)
   {
     return true;
@@ -345,8 +325,7 @@
                                                           DRIZZLE_TYPE_LONGLONG,
                                                           0,
                                                           (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                          "",
-                                                          OPEN_FRM_ONLY);
+                                                          "");
   if (max_len == NULL)
   {
     return true;
@@ -357,8 +336,7 @@
                                                             DRIZZLE_TYPE_LONGLONG,
                                                             0,
                                                             (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                            "",
-                                                            OPEN_FRM_ONLY);
+                                                            "");
   if (octet_len == NULL)
   {
     return true;
@@ -369,8 +347,7 @@
                                                            DRIZZLE_TYPE_LONGLONG,
                                                            0,
                                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                           "",
-                                                           OPEN_FRM_ONLY);
+                                                           "");
   if (num_prec == NULL)
   {
     return true;
@@ -381,8 +358,7 @@
                                                             DRIZZLE_TYPE_LONGLONG,
                                                             0,
                                                             (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                            "",
-                                                            OPEN_FRM_ONLY);
+                                                            "");
   if (num_scale == NULL)
   {
     return true;
@@ -393,8 +369,7 @@
                                                                 DRIZZLE_TYPE_VARCHAR,
                                                                 0,
                                                                 1,
-                                                                "",
-                                                                OPEN_FRM_ONLY);
+                                                                "");
   if (char_set_name == NULL)
   {
     return true;
@@ -405,20 +380,19 @@
                                                             DRIZZLE_TYPE_VARCHAR,
                                                             0,
                                                             1,
-                                                            "Collation",
-                                                            OPEN_FRM_ONLY);
+                                                            "Collation");
   if (coll_name == NULL)
   {
     return true;
   }
 
   const drizzled::plugin::ColumnInfo *col_type= new(std::nothrow) drizzled::plugin::ColumnInfo("COLUMN_TYPE",
-                                                           65535,
+                                                           64,
+                                                           //65535,
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "Type",
-                                                           OPEN_FRM_ONLY);
+                                                           "Type");
   if (col_type == NULL)
   {
     return true;
@@ -429,8 +403,7 @@
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           0,
-                                                          "Key",
-                                                          OPEN_FRM_ONLY);
+                                                          "Key");
   if (col_key == NULL)
   {
     return true;
@@ -441,8 +414,7 @@
                                                         DRIZZLE_TYPE_VARCHAR,
                                                         0,
                                                         0,
-                                                        "Extra",
-                                                        OPEN_FRM_ONLY);
+                                                        "Extra");
   if (extra == NULL)
   {
     return true;
@@ -453,8 +425,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "Privileges",
-                                                       OPEN_FRM_ONLY);
+                                                       "Privileges");
   if (priv == NULL)
   {
     return true;
@@ -465,8 +436,7 @@
                                                               DRIZZLE_TYPE_VARCHAR,
                                                               0,
                                                               0,
-                                                              "Comment",
-                                                              OPEN_FRM_ONLY);
+                                                              "Comment");
   if (col_comment == NULL)
   {
     return true;
@@ -477,8 +447,7 @@
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           0,
-                                                          "Storage",
-                                                          OPEN_FRM_ONLY);
+                                                          "Storage");
   if (storage == NULL)
   {
     return true;
@@ -489,8 +458,7 @@
                                                          DRIZZLE_TYPE_VARCHAR,
                                                          0,
                                                          0,
-                                                         "Format",
-                                                         OPEN_FRM_ONLY);
+                                                         "Format");
   if (format == NULL)
   {
     return true;
@@ -531,8 +499,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       1,
-                                                      "",
-                                                      OPEN_FULL_TABLE);
+                                                      "");
   if (cat == NULL)
   {
     return true;
@@ -543,8 +510,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       0,
-                                                      "",
-                                                      OPEN_FULL_TABLE);
+                                                      "");
   if (sch == NULL)
   {
     return true;
@@ -555,8 +521,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "",
-                                                       OPEN_FULL_TABLE);
+                                                       "");
   if (name == NULL)
   {
     return true;
@@ -567,8 +532,7 @@
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           1,
-                                                          "",
-                                                          OPEN_FULL_TABLE);
+                                                          "");
   if (tab_cat == NULL)
   {
     return true;
@@ -579,8 +543,7 @@
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           0,
-                                                          "",
-                                                          OPEN_FULL_TABLE);
+                                                          "");
   if (tab_sch == NULL)
   {
     return true;
@@ -591,8 +554,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "",
-                                                           OPEN_FULL_TABLE);
+                                                           "");
   if (tab_name == NULL)
   {
     return true;
@@ -603,8 +565,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "",
-                                                           OPEN_FULL_TABLE);
+                                                           "");
   if (col_name == NULL)
   {
     return true;
@@ -614,8 +575,7 @@
                                                           DRIZZLE_TYPE_LONGLONG,
                                                           0,
                                                           0,
-                                                          "",
-                                                          OPEN_FULL_TABLE);
+                                                          "");
   if (ord_pos == NULL)
   {
     return true;
@@ -626,8 +586,7 @@
                                                               DRIZZLE_TYPE_LONGLONG,
                                                               0,
                                                               1,
-                                                              "",
-                                                              OPEN_FULL_TABLE);
+                                                              "");
   if (pos_in_uniq == NULL)
   {
     return true;
@@ -638,8 +597,7 @@
                                                               DRIZZLE_TYPE_VARCHAR,
                                                               0,
                                                               1,
-                                                              "",
-                                                              OPEN_FULL_TABLE);
+                                                              "");
   if (ref_tab_sch == NULL)
   {
     return true;
@@ -650,8 +608,7 @@
                                                                DRIZZLE_TYPE_VARCHAR,
                                                                0,
                                                                1,
-                                                               "",
-                                                               OPEN_FULL_TABLE);
+                                                               "");
   if (ref_tab_name == NULL)
   {
     return true;
@@ -662,8 +619,7 @@
                                                                DRIZZLE_TYPE_VARCHAR,
                                                                0,
                                                                1,
-                                                               "",
-                                                               OPEN_FULL_TABLE);
+                                                               "");
   if (ref_col_name == NULL)
   {
     return true;
@@ -692,8 +648,7 @@
                                                      DRIZZLE_TYPE_VARCHAR,
                                                      0,
                                                      0,
-                                                     "Database",
-                                                     SKIP_OPEN_TABLE);
+                                                     "Database");
   if (db == NULL)
   {
     return true;
@@ -704,8 +659,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       0,
-                                                      "Table",
-                                                      SKIP_OPEN_TABLE);
+                                                      "Table");
   if (tab == NULL)
   {
     return true;
@@ -716,8 +670,7 @@
                                                          DRIZZLE_TYPE_LONGLONG,
                                                          0,
                                                          0,
-                                                         "In_use",
-                                                         SKIP_OPEN_TABLE);
+                                                         "In_use");
   if (in_use == NULL)
   {
     return true;
@@ -728,8 +681,7 @@
                                                               DRIZZLE_TYPE_LONGLONG,
                                                               0,
                                                               0,
-                                                              "Name_locked",
-                                                              SKIP_OPEN_TABLE);
+                                                              "Name_locked");
   if (name_locked == NULL)
   {
     return true;
@@ -750,8 +702,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "Name",
-                                                       SKIP_OPEN_TABLE);
+                                                       "Name");
   if (name == NULL)
   {
     return true;
@@ -762,8 +713,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       0,
-                                                      "",
-                                                      SKIP_OPEN_TABLE);
+                                                      "");
   if (ver == NULL)
   {
     return true;
@@ -774,8 +724,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "Status",
-                                                       SKIP_OPEN_TABLE);
+                                                       "Status");
   if (stat == NULL)
   {
     return true;
@@ -786,20 +735,19 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       1,
-                                                      "",
-                                                      SKIP_OPEN_TABLE);
+                                                      "");
   if (aut == NULL)
   {
     return true;
   }
 
   const drizzled::plugin::ColumnInfo *descrip= new(std::nothrow) drizzled::plugin::ColumnInfo("PLUGIN_DESCRIPTION",
-                                                          65535,
+                                                          64,
+                                                          //65535,
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           1,
-                                                          "",
-                                                          SKIP_OPEN_TABLE);
+                                                          "");
   if (descrip == NULL)
   {
     return true;
@@ -810,8 +758,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       1,
-                                                      "License",
-                                                      SKIP_OPEN_TABLE);
+                                                      "License");
   if (lic == NULL)
   {
     return true;
@@ -837,8 +784,7 @@
                                                          DRIZZLE_TYPE_LONGLONG,
                                                          0,
                                                          0,
-                                                         "Id",
-                                                         SKIP_OPEN_TABLE);
+                                                         "Id");
   if (id_col == NULL)
   {
     return true;
@@ -849,8 +795,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "User",
-                                                           SKIP_OPEN_TABLE);
+                                                           "User");
   if (user_col == NULL)
   {
     return true;
@@ -861,8 +806,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "Host",
-                                                           SKIP_OPEN_TABLE);
+                                                           "Host");
   if (host_col == NULL)
   {
     return true;
@@ -873,8 +817,7 @@
                                                          DRIZZLE_TYPE_VARCHAR,
                                                          0,
                                                          1,
-                                                         "Db",
-                                                         SKIP_OPEN_TABLE);
+                                                         "Db");
   if (db_col == NULL)
   {
     return true;
@@ -885,8 +828,7 @@
                                                               DRIZZLE_TYPE_VARCHAR,
                                                               0,
                                                               0,
-                                                              "Command",
-                                                              SKIP_OPEN_TABLE);
+                                                              "Command");
   if (command_col == NULL)
   {
     return true;
@@ -897,8 +839,7 @@
                                                            DRIZZLE_TYPE_LONGLONG,
                                                            0,
                                                            0,
-                                                           "Time",
-                                                           SKIP_OPEN_TABLE);
+                                                           "Time");
   if (time_col == NULL)
   {
     return true;
@@ -909,8 +850,7 @@
                                                             DRIZZLE_TYPE_VARCHAR,
                                                             0,
                                                             1,
-                                                            "State",
-                                                            SKIP_OPEN_TABLE);
+                                                            "State");
   if (state_col == NULL)
   {
     return true;
@@ -921,8 +861,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            1,
-                                                           "Info",
-                                                           SKIP_OPEN_TABLE);
+                                                           "Info");
   if (info_col == NULL)
   {
     return true;
@@ -953,8 +892,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       1,
-                                                      "",
-                                                      OPEN_FULL_TABLE);
+                                                      "");
 
   if (cat == NULL)
   {
@@ -966,8 +904,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       0,
-                                                      "",
-                                                      OPEN_FULL_TABLE);
+                                                      "");
   if (sch == NULL)
   {
     return true;
@@ -978,8 +915,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "",
-                                                       OPEN_FULL_TABLE);
+                                                       "");
   if (name == NULL)
   {
     return true;
@@ -990,8 +926,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            1,
-                                                           "",
-                                                           OPEN_FULL_TABLE);
+                                                           "");
   if (uniq_cat == NULL)
   {
     return true;
@@ -1002,8 +937,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "",
-                                                           OPEN_FULL_TABLE);
+                                                           "");
   if (uniq_sch == NULL)
   {
     return true;
@@ -1014,8 +948,7 @@
                                                             DRIZZLE_TYPE_VARCHAR,
                                                             0,
                                                             MY_I_S_MAYBE_NULL,
-                                                            "",
-                                                            OPEN_FULL_TABLE);
+                                                            "");
   if (uniq_name == NULL)
   {
     return true;
@@ -1026,8 +959,7 @@
                                                         DRIZZLE_TYPE_VARCHAR,
                                                         0,
                                                         0,
-                                                        "",
-                                                        OPEN_FULL_TABLE);
+                                                        "");
   if (match == NULL)
   {
     return true;
@@ -1038,8 +970,7 @@
                                                          DRIZZLE_TYPE_VARCHAR,
                                                          0,
                                                          0,
-                                                         "",
-                                                         OPEN_FULL_TABLE);
+                                                         "");
   if (update == NULL)
   {
     return true;
@@ -1050,8 +981,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "",
-                                                           OPEN_FULL_TABLE);
+                                                           "");
   if (del_rule == NULL)
   {
     return true;
@@ -1062,8 +992,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "",
-                                                           OPEN_FULL_TABLE);
+                                                           "");
   if (tab_name == NULL)
   {
     return true;
@@ -1074,8 +1003,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "",
-                                                           OPEN_FULL_TABLE);
+                                                           "");
   if (ref_name == NULL)
   {
     return true;
@@ -1106,8 +1034,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0, 
                                                            1, 
-                                                           "", 
-                                                           SKIP_OPEN_TABLE);
+                                                           "");
   if (cat_name == NULL)
   {
     return true;
@@ -1118,8 +1045,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0, 
                                                            0, 
-                                                           "Database", 
-                                                           SKIP_OPEN_TABLE);
+                                                           "Database");
   if (sch_name == NULL)
   {
     return true;
@@ -1130,8 +1056,7 @@
                                                           DRIZZLE_TYPE_VARCHAR, 
                                                           0, 
                                                           0, 
-                                                          "",
-                                                          SKIP_OPEN_TABLE);
+                                                          "");
   if (cs_name == NULL)
   {
     return true;
@@ -1142,8 +1067,7 @@
                                                             DRIZZLE_TYPE_VARCHAR, 
                                                             0, 
                                                             0, 
-                                                            "",
-                                                            SKIP_OPEN_TABLE);
+                                                            "");
   if (coll_name == NULL)
   {
     return true;
@@ -1154,8 +1078,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0, 
                                                            1, 
-                                                           "", 
-                                                           SKIP_OPEN_TABLE);
+                                                           "");
   if (sql_path == NULL)
   {
     return true;
@@ -1177,8 +1100,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       1,
-                                                      "",
-                                                      OPEN_FRM_ONLY);
+                                                      "");
   if (cat == NULL)
   {
     return true;
@@ -1189,8 +1111,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       0,
-                                                      "",
-                                                      OPEN_FRM_ONLY);
+                                                      "");
   if (sch == NULL)
   {
     return true;
@@ -1201,8 +1122,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "Table",
-                                                       OPEN_FRM_ONLY);
+                                                       "Table");
   if (name == NULL)
   {
     return true;
@@ -1213,8 +1133,7 @@
                                                        DRIZZLE_TYPE_LONGLONG,
                                                        0,
                                                        0,
-                                                       "Non_unique",
-                                                       OPEN_FRM_ONLY);
+                                                       "Non_unique");
   if (uniq == NULL)
   {
     return true;
@@ -1225,8 +1144,7 @@
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           0,
-                                                          "",
-                                                          OPEN_FRM_ONLY);
+                                                          "");
   if (idx_sch == NULL)
   {
     return true;
@@ -1237,8 +1155,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "Key_name",
-                                                           OPEN_FRM_ONLY);
+                                                           "Key_name");
   if (idx_name == NULL)
   {
     return true;
@@ -1249,8 +1166,7 @@
                                                              DRIZZLE_TYPE_LONGLONG,
                                                              0,
                                                              0,
-                                                             "Seq_in_index",
-                                                             OPEN_FRM_ONLY);
+                                                             "Seq_in_index");
   if (seq_in_idx == NULL)
   {
     return true;
@@ -1261,8 +1177,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "Column_name",
-                                                           OPEN_FRM_ONLY);
+                                                           "Column_name");
   if (col_name == NULL)
   {
     return true;
@@ -1273,8 +1188,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        1,
-                                                       "Collation",
-                                                       OPEN_FRM_ONLY);
+                                                       "Collation");
   if (coll == NULL)
   {
     return true;
@@ -1285,8 +1199,7 @@
                                                        DRIZZLE_TYPE_LONGLONG,
                                                        0,
                                                        1,
-                                                       "Cardinality",
-                                                       OPEN_FULL_TABLE);
+                                                       "Cardinality");
   if (card == NULL)
   {
     return true;
@@ -1297,8 +1210,7 @@
                                                            DRIZZLE_TYPE_LONGLONG,
                                                            0,
                                                            1,
-                                                           "Sub_part",
-                                                           OPEN_FRM_ONLY);
+                                                           "Sub_part");
   if (sub_part == NULL)
   {
     return true;
@@ -1309,8 +1221,7 @@
                                                          DRIZZLE_TYPE_VARCHAR,
                                                          0,
                                                          1,
-                                                         "Packed",
-                                                         OPEN_FRM_ONLY);
+                                                         "Packed");
   if (packed == NULL)
   {
     return true;
@@ -1321,8 +1232,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "Null",
-                                                           OPEN_FRM_ONLY);
+                                                           "Null");
   if (nullable == NULL)
   {
     return true;
@@ -1333,8 +1243,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "Index_type",
-                                                           OPEN_FULL_TABLE);
+                                                           "Index_type");
   if (idx_type == NULL)
   {
     return true;
@@ -1345,8 +1254,7 @@
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           1,
-                                                          "Comment",
-                                                          OPEN_FRM_ONLY);
+                                                          "Comment");
   if (comment == NULL)
   {
     return true;
@@ -1357,8 +1265,7 @@
                                                               DRIZZLE_TYPE_VARCHAR,
                                                               0,
                                                               0,
-                                                              "Index_Comment",
-                                                              OPEN_FRM_ONLY);
+                                                              "Index_Comment");
   if (idx_comment == NULL)
   {
     return true;
@@ -1391,8 +1298,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "Variable_name",
-                                                       SKIP_OPEN_TABLE);
+                                                       "Variable_name");
   if (name == NULL)
   {
     return true;
@@ -1403,8 +1309,7 @@
                                                         DRIZZLE_TYPE_VARCHAR,
                                                         0,
                                                         1,
-                                                        "Value",
-                                                        SKIP_OPEN_TABLE);
+                                                        "Value");
   if (value == NULL)
   {
     return true;
@@ -1423,8 +1328,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       1,
-                                                      "",
-                                                      OPEN_FULL_TABLE);
+                                                      "");
   if (cat == NULL)
   {
     return true;
@@ -1435,8 +1339,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       0,
-                                                      "",
-                                                      OPEN_FULL_TABLE);
+                                                      "");
   if (sch == NULL)
   {
     return true;
@@ -1447,8 +1350,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "",
-                                                       OPEN_FULL_TABLE);
+                                                       "");
   if (name == NULL)
   {
     return true;
@@ -1459,8 +1361,7 @@
                                                           DRIZZLE_TYPE_VARCHAR,
                                                           0,
                                                           0,
-                                                          "",
-                                                          OPEN_FULL_TABLE);
+                                                          "");
   if (tab_sch == NULL)
   {
     return true;
@@ -1471,8 +1372,7 @@
                                                            DRIZZLE_TYPE_VARCHAR,
                                                            0,
                                                            0,
-                                                           "",
-                                                           OPEN_FULL_TABLE);
+                                                           "");
   if (tab_name == NULL)
   {
     return true;
@@ -1483,8 +1383,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "",
-                                                       OPEN_FULL_TABLE);
+                                                       "");
   if (type == NULL)
   {
     return true;
@@ -1507,8 +1406,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       1,
-                                                      "",
-                                                      SKIP_OPEN_TABLE);
+                                                      "");
   if (cat == NULL)
   {
     return true;
@@ -1519,8 +1417,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       0,
-                                                      "",
-                                                      SKIP_OPEN_TABLE);
+                                                      "");
   if (sch == NULL)
   {
     return true;
@@ -1531,8 +1428,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "Name",
-                                                       SKIP_OPEN_TABLE);
+                                                       "Name");
   if (name == NULL)
   {
     return true;
@@ -1543,8 +1439,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "",
-                                                       OPEN_FRM_ONLY);
+                                                       "");
   if (type == NULL)
   {
     return true;
@@ -1555,8 +1450,7 @@
                                                          DRIZZLE_TYPE_VARCHAR,
                                                          0,
                                                          1,
-                                                         "Engine",
-                                                         OPEN_FRM_ONLY);
+                                                         "Engine");
   if (engine == NULL)
   {
     return true;
@@ -1567,8 +1461,7 @@
                                                           DRIZZLE_TYPE_LONGLONG,
                                                           0,
                                                           (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                          "Version",
-                                                          OPEN_FRM_ONLY);
+                                                          "Version");
   if (version == NULL)
   {
     return true;
@@ -1579,8 +1472,7 @@
                                                              DRIZZLE_TYPE_VARCHAR,
                                                              0,
                                                              1,
-                                                             "Row_format",
-                                                             OPEN_FULL_TABLE);
+                                                             "Row_format");
   if (row_format == NULL)
   {
     return true;
@@ -1591,8 +1483,7 @@
                                                            DRIZZLE_TYPE_LONGLONG,
                                                            0,
                                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                           "Rows",
-                                                           OPEN_FULL_TABLE);
+                                                           "Rows");
   if (tab_rows == NULL)
   {
     return true;
@@ -1603,8 +1494,7 @@
                                                               DRIZZLE_TYPE_LONGLONG,
                                                               0,
                                                               (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                              "Avg_row_length",
-                                                              OPEN_FULL_TABLE);
+                                                              "Avg_row_length");
   if (avg_row_len == NULL)
   {
     return true;
@@ -1615,8 +1505,7 @@
                                                            DRIZZLE_TYPE_LONGLONG,
                                                            0,
                                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                           "Data_length",
-                                                           OPEN_FULL_TABLE);
+                                                           "Data_length");
   if (data_len == NULL)
   {
     return true;
@@ -1627,8 +1516,7 @@
                                                                DRIZZLE_TYPE_LONGLONG,
                                                                0,
                                                                (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                               "Max_data_length",
-                                                               OPEN_FULL_TABLE);
+                                                               "Max_data_length");
   if (max_data_len == NULL)
   {
     return true;
@@ -1639,8 +1527,7 @@
                                                           DRIZZLE_TYPE_LONGLONG,
                                                           0,
                                                           (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                          "Index_length",
-                                                          OPEN_FULL_TABLE);
+                                                          "Index_length");
   if (idx_len == NULL)
   {
     return true;
@@ -1651,8 +1538,7 @@
                                                            DRIZZLE_TYPE_LONGLONG,
                                                            0,
                                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                           "Data_free",
-                                                           OPEN_FULL_TABLE);
+                                                           "Data_free");
   if (data_free == NULL)
   {
     return true;
@@ -1663,8 +1549,7 @@
                                                            DRIZZLE_TYPE_LONGLONG,
                                                            0,
                                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                           "Auto_increment",
-                                                           OPEN_FULL_TABLE);
+                                                           "Auto_increment");
   if (auto_inc == NULL)
   {
     return true;
@@ -1675,8 +1560,7 @@
                                                               DRIZZLE_TYPE_DATETIME,
                                                               0,
                                                               1,
-                                                              "Create_time",
-                                                              OPEN_FULL_TABLE);
+                                                              "Create_time");
   if (create_time == NULL)
   {
     return true;
@@ -1687,8 +1571,7 @@
                                                               DRIZZLE_TYPE_DATETIME,
                                                               0,
                                                               1,
-                                                              "Update_time",
-                                                              OPEN_FULL_TABLE);
+                                                              "Update_time");
   if (update_time == NULL)
   {
     return true;
@@ -1699,8 +1582,7 @@
                                                              DRIZZLE_TYPE_DATETIME,
                                                              0,
                                                              1,
-                                                             "Check_time",
-                                                             OPEN_FULL_TABLE);
+                                                             "Check_time");
   if (check_time == NULL)
   {
     return true;
@@ -1711,8 +1593,7 @@
                                                              DRIZZLE_TYPE_VARCHAR,
                                                              0,
                                                              1,
-                                                             "Collation",
-                                                             OPEN_FRM_ONLY);
+                                                             "Collation");
   if (table_coll == NULL)
   {
     return true;
@@ -1723,8 +1604,7 @@
                                                            DRIZZLE_TYPE_LONGLONG,
                                                            0,
                                                            (MY_I_S_MAYBE_NULL | MY_I_S_UNSIGNED),
-                                                           "Checksum",
-                                                           OPEN_FULL_TABLE);
+                                                           "Checksum");
   if (checksum == NULL)
   {
     return true;
@@ -1735,8 +1615,7 @@
                                                              DRIZZLE_TYPE_VARCHAR,
                                                              0,
                                                              1,
-                                                             "Create_options",
-                                                             OPEN_FRM_ONLY);
+                                                             "Create_options");
   if (create_opt == NULL)
   {
     return true;
@@ -1747,8 +1626,7 @@
                                                               DRIZZLE_TYPE_VARCHAR,
                                                               0,
                                                               0,
-                                                              "Comment",
-                                                              OPEN_FRM_ONLY);
+                                                              "Comment");
   if (tab_comment == NULL)
   {
     return true;
@@ -1787,8 +1665,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       1,
-                                                      "",
-                                                      SKIP_OPEN_TABLE);
+                                                      "");
   if (cat == NULL)
   {
     return true;
@@ -1799,8 +1676,7 @@
                                                       DRIZZLE_TYPE_VARCHAR,
                                                       0,
                                                       0,
-                                                      "",
-                                                      SKIP_OPEN_TABLE);
+                                                      "");
   if (sch == NULL)
   {
     return true;
@@ -1811,8 +1687,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "Tables_in_",
-                                                       SKIP_OPEN_TABLE);
+                                                       "Tables_in_");
   if (name == NULL)
   {
     return true;
@@ -1823,8 +1698,7 @@
                                                        DRIZZLE_TYPE_VARCHAR,
                                                        0,
                                                        0,
-                                                       "Table_type",
-                                                       OPEN_FRM_ONLY);
+                                                       "Table_type");
   if (type == NULL)
   {
     return true;
 
=== modified file 'plugin/info_schema/info_schema_methods.cc'
--- plugin/info_schema/info_schema_methods.cc	2009-10-16 00:38:56 +0000
+++ plugin/info_schema/info_schema_methods.cc	2009-10-29 23:56:14 +0000
@@ -29,6 +29,7 @@
 #include <drizzled/tztime.h>
 #include <drizzled/sql_base.h>
 #include <drizzled/plugin/client.h>
+#include <drizzled/join_table.h>
 
 #include "info_schema_methods.h"
 
@@ -36,6 +37,7 @@
 #include <string>
 
 using namespace std;
+using namespace drizzled;
 
 static inline void make_upper(char *buf)
 {
@@ -186,6 +188,9 @@
           break;
         }
         table->restoreRecordAsDefault();
+        table->setWriteSet(0);
+        table->setWriteSet(1);
+        table->setWriteSet(2);
         table->field[0]->store(name_buffer, strlen(name_buffer),
                                system_charset_info);
         table->field[1]->store(pos, (uint32_t) (end - pos), system_charset_info);
@@ -193,8 +198,8 @@
 
         pthread_mutex_unlock(&LOCK_global_system_variables);
 
-        if (schema_table_store_record(session, table))
-          return true;
+        TableList *tmp_list= table->pos_in_table_list;
+        tmp_list->schema_table->addRow(table->record[0], table->s->reclength);
       }
     }
   }
@@ -202,7 +207,7 @@
   return false;
 }
 
-int CharSetISMethods::fillTable(Session *session, TableList *tables, COND *)
+int CharSetISMethods::fillTable(Session *session, TableList *tables)
 {
   CHARSET_INFO **cs;
   const char *wild= session->lex->wild ? session->lex->wild->ptr() : NULL;
@@ -220,13 +225,17 @@
     {
       const char *comment;
       table->restoreRecordAsDefault();
+      /* set the appropriate bits in the write bitset */
+      table->setWriteSet(0);
+      table->setWriteSet(1);
+      table->setWriteSet(2);
+      table->setWriteSet(3);
       table->field[0]->store(tmp_cs->csname, strlen(tmp_cs->csname), scs);
       table->field[1]->store(tmp_cs->name, strlen(tmp_cs->name), scs);
       comment= tmp_cs->comment ? tmp_cs->comment : "";
       table->field[2]->store(comment, strlen(comment), scs);
       table->field[3]->store((int64_t) tmp_cs->mbmaxlen, true);
-      if (schema_table_store_record(session, table))
-        return 1;
+      tables->schema_table->addRow(table->record[0], table->s->reclength);
     }
   }
   return 0;
@@ -258,7 +267,7 @@
   return 0;
 }
 
-int CollationISMethods::fillTable(Session *session, TableList *tables, COND *)
+int CollationISMethods::fillTable(Session *session, TableList *tables)
 {
   CHARSET_INFO **cs;
   const char *wild= session->lex->wild ? session->lex->wild->ptr() : NULL;
@@ -283,6 +292,13 @@
       {
         const char *tmp_buff;
         table->restoreRecordAsDefault();
+        /* set the appropriate bits in the write bitset */
+        table->setWriteSet(0);
+        table->setWriteSet(1);
+        table->setWriteSet(2);
+        table->setWriteSet(3);
+        table->setWriteSet(4);
+        table->setWriteSet(5);
         table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
         table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
         table->field[2]->store((int64_t) tmp_cl->number, true);
@@ -291,15 +307,14 @@
         tmp_buff= (tmp_cl->state & MY_CS_COMPILED)? "Yes" : "";
         table->field[4]->store(tmp_buff, strlen(tmp_buff), scs);
         table->field[5]->store((int64_t) tmp_cl->strxfrm_multiply, true);
-        if (schema_table_store_record(session, table))
-          return 1;
+        tables->schema_table->addRow(table->record[0], table->s->reclength);
       }
     }
   }
   return 0;
 }
 
-int CollCharISMethods::fillTable(Session *session, TableList *tables, COND *)
+int CollCharISMethods::fillTable(Session *, TableList *tables)
 {
   CHARSET_INFO **cs;
   Table *table= tables->table;
@@ -318,10 +333,11 @@
           ! my_charset_same(tmp_cs,tmp_cl))
         continue;
       table->restoreRecordAsDefault();
+      table->setWriteSet(0);
+      table->setWriteSet(1);
       table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
       table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
-      if (schema_table_store_record(session, table))
-        return 1;
+      tables->schema_table->addRow(table->record[0], table->s->reclength);
     }
   }
   return 0;
@@ -367,6 +383,13 @@
                                    int64_t idx)
 {
   const CHARSET_INFO * const cs= system_charset_info;
+  /* set the appropriate bits in the write bitset */
+  table->setWriteSet(1);
+  table->setWriteSet(2);
+  table->setWriteSet(4);
+  table->setWriteSet(5);
+  table->setWriteSet(6);
+  table->setWriteSet(7);
   table->field[1]->store(db_name->str, db_name->length, cs);
   table->field[2]->store(key_name, key_len, cs);
   table->field[4]->store(db_name->str, db_name->length, cs);
@@ -375,11 +398,12 @@
   table->field[7]->store((int64_t) idx, true);
 }
 
-int KeyColUsageISMethods::processTable(Session *session,
-                                              TableList *tables,
-                                              Table *table, bool res,
-                                              LEX_STRING *db_name,
-                                              LEX_STRING *table_name) const
+int KeyColUsageISMethods::processTable(plugin::InfoSchemaTable *,
+                                       Session *session,
+                                       TableList *tables,
+                                       Table *table, bool res,
+                                       LEX_STRING *db_name,
+                                       LEX_STRING *table_name)
 {
   if (res)
   {
@@ -418,10 +442,8 @@
                                  key_part->field->field_name,
                                  strlen(key_part->field->field_name),
                                  (int64_t) f_idx);
-          if (schema_table_store_record(session, table))
-          {
-            return (1);
-          }
+          tables->schema_table->addRow(table->record[0],
+                                       table->s->reclength);
         }
       }
     }
@@ -446,6 +468,10 @@
                                f_key_info->forein_id->length,
                                f_info->str, f_info->length,
                                (int64_t) f_idx);
+        table->setWriteSet(8);
+        table->setWriteSet(9);
+        table->setWriteSet(10);
+        table->setWriteSet(11);
         table->field[8]->store((int64_t) f_idx, true);
         table->field[8]->set_notnull();
         table->field[9]->store(f_key_info->referenced_db->str,
@@ -459,10 +485,8 @@
         table->field[11]->store(r_info->str, r_info->length,
                                 system_charset_info);
         table->field[11]->set_notnull();
-        if (schema_table_store_record(session, table))
-        {
-          return (1);
-        }
+        tables->schema_table->addRow(table->record[0],
+                                     table->s->reclength);
       }
     }
   }
@@ -473,17 +497,21 @@
 inline bool open_list_store(Table *table, open_table_list_st& open_list)
 {
   table->restoreRecordAsDefault();
+  table->setWriteSet(0);
+  table->setWriteSet(1);
+  table->setWriteSet(2);
+  table->setWriteSet(3);
   table->field[0]->store(open_list.db.c_str(), open_list.db.length(), system_charset_info);
   table->field[1]->store(open_list.table.c_str(), open_list.table.length(), system_charset_info);
   table->field[2]->store((int64_t) open_list.in_use, true);
   table->field[3]->store((int64_t) open_list.locked, true);
-  if (schema_table_store_record(table->in_use, table))
-    return true;
+  TableList *tmp= table->pos_in_table_list;
+  tmp->schema_table->addRow(table->record[0], table->s->reclength);
 
   return false;
 }
 
-int OpenTablesISMethods::fillTable(Session *session, TableList *tables, COND *)
+int OpenTablesISMethods::fillTable(Session *session, TableList *tables)
 {
   const char *wild= session->lex->wild ? session->lex->wild->ptr() : NULL;
 
@@ -497,9 +525,16 @@
 {
   Session *session;
   Table *table;
+  plugin::InfoSchemaTable *is_table;
 public:
-  ShowPlugins(Session *session_arg, Table *table_arg)
-    : session(session_arg), table(table_arg) {}
+  ShowPlugins(Session *session_arg, 
+              Table *table_arg,
+              plugin::InfoSchemaTable *is_table_arg)
+    : 
+      session(session_arg), 
+      table(table_arg),
+      is_table(is_table_arg)
+  {}
 
   result_type operator() (argument_type plugin)
   {
@@ -508,6 +543,14 @@
 
     table->restoreRecordAsDefault();
 
+    /* mark fields that will be written to in the write bitset */
+    table->setWriteSet(0);
+    table->setWriteSet(1);
+    table->setWriteSet(2);
+    table->setWriteSet(3);
+    table->setWriteSet(4);
+    table->setWriteSet(5);
+
     table->field[0]->store(plugin->getName().c_str(),
                            plugin->getName().size(), cs);
 
@@ -569,18 +612,21 @@
     }
     table->field[5]->set_notnull();
 
-    return schema_table_store_record(session, table);
+    is_table->addRow(table->record[0], table->s->reclength);
+    return false;
   }
 };
 
-int PluginsISMethods::fillTable(Session *session, TableList *tables, COND *)
+int PluginsISMethods::fillTable(Session *session, TableList *tables)
 {
   Table *table= tables->table;
 
   drizzled::plugin::Registry &registry= drizzled::plugin::Registry::singleton();
   vector<drizzled::plugin::Handle *> plugins= registry.getList(true);
   vector<drizzled::plugin::Handle *>::iterator iter=
-    find_if(plugins.begin(), plugins.end(), ShowPlugins(session, table));
+    find_if(plugins.begin(), 
+            plugins.end(), 
+            ShowPlugins(session, table, tables->schema_table));
   if (iter != plugins.end())
   {
     return 1;
@@ -588,7 +634,7 @@
   return (0);
 }
 
-int ProcessListISMethods::fillTable(Session* session, TableList* tables, COND*)
+int ProcessListISMethods::fillTable(Session* session, TableList* tables)
 {
   Table *table= tables->table;
   const CHARSET_INFO * const cs= system_charset_info;
@@ -615,6 +661,14 @@
         continue;
 
       table->restoreRecordAsDefault();
+      table->setWriteSet(0);
+      table->setWriteSet(1);
+      table->setWriteSet(2);
+      table->setWriteSet(3);
+      table->setWriteSet(4);
+      table->setWriteSet(5);
+      table->setWriteSet(6);
+      table->setWriteSet(7);
       /* ID */
       table->field[0]->store((int64_t) tmp->thread_id, true);
       /* USER */
@@ -667,11 +721,7 @@
         table->field[7]->set_notnull();
       }
 
-      if (schema_table_store_record(session, table))
-      {
-        pthread_mutex_unlock(&LOCK_thread_count);
-        return(1);
-      }
+      tables->schema_table->addRow(table->record[0], table->s->reclength);
     }
   }
 
@@ -680,10 +730,10 @@
 }
 
 int
-RefConstraintsISMethods::processTable(Session *session, TableList *tables,
+RefConstraintsISMethods::processTable(plugin::InfoSchemaTable *, 
+                                      Session *session, TableList *tables,
                                       Table *table, bool res,
                                       LEX_STRING *db_name, LEX_STRING *table_name)
-  const
 {
   const CHARSET_INFO * const cs= system_charset_info;
 
@@ -709,6 +759,15 @@
     while ((f_key_info= it++))
     {
       table->restoreRecordAsDefault();
+      table->setWriteSet(1);
+      table->setWriteSet(2);
+      table->setWriteSet(4);
+      table->setWriteSet(5);
+      table->setWriteSet(6);
+      table->setWriteSet(7);
+      table->setWriteSet(8);
+      table->setWriteSet(9);
+      table->setWriteSet(10);
       table->field[1]->store(db_name->str, db_name->length, cs);
       table->field[9]->store(table_name->str, table_name->length, cs);
       table->field[2]->store(f_key_info->forein_id->str,
@@ -732,26 +791,29 @@
                              f_key_info->update_method->length, cs);
       table->field[8]->store(f_key_info->delete_method->str,
                              f_key_info->delete_method->length, cs);
-      if (schema_table_store_record(session, table))
-      {
-        return (1);
-      }
+      tables->schema_table->addRow(table->record[0],
+                                   table->s->reclength);
     }
   }
   return (0);
 }
 
-static bool store_schema_schemata(Session* session, Table *table, LEX_STRING *db_name,
+static bool store_schema_schemata(Session *, Table *table, LEX_STRING *db_name,
                                   const CHARSET_INFO * const cs)
 {
   table->restoreRecordAsDefault();
+  table->setWriteSet(1);
+  table->setWriteSet(2);
+  table->setWriteSet(3);
   table->field[1]->store(db_name->str, db_name->length, system_charset_info);
   table->field[2]->store(cs->csname, strlen(cs->csname), system_charset_info);
   table->field[3]->store(cs->name, strlen(cs->name), system_charset_info);
-  return schema_table_store_record(session, table);
+  TableList *tmp= table->pos_in_table_list;
+  tmp->schema_table->addRow(table->record[0], table->s->reclength);
+  return 0;
 }
 
-int SchemataISMethods::fillTable(Session *session, TableList *tables, COND *cond)
+int SchemataISMethods::fillTable(Session *session, TableList *tables)
 {
   /*
     TODO: fill_schema_shemata() is called when new client is connected.
@@ -762,6 +824,8 @@
   vector<LEX_STRING*> db_names;
   bool with_i_schema;
   Table *table= tables->table;
+  /* the WHERE clause */
+  COND *cond= table->reginfo.join_tab->select_cond;
 
   if (get_lookup_field_values(session, cond, tables, &lookup_field_vals))
     return(0);
@@ -810,7 +874,7 @@
   return(0);
 }
 
-int SchemataISMethods::oldFormat(Session *session, drizzled::plugin::InfoSchemaTable *schema_table)
+int SchemataISMethods::oldFormat(Session *session, plugin::InfoSchemaTable *schema_table)
   const
 {
   char tmp[128];
@@ -840,10 +904,11 @@
   return 0;
 }
 
-int StatsISMethods::processTable(Session *session, TableList *tables,
-                                  Table *table, bool res,
-                                  LEX_STRING *db_name,
-                                  LEX_STRING *table_name) const
+int StatsISMethods::processTable(plugin::InfoSchemaTable *store_table, 
+                                 Session *session, TableList *tables,
+                                 Table *table, bool res,
+                                 LEX_STRING *db_name,
+                                 LEX_STRING *table_name)
 {
   const CHARSET_INFO * const cs= system_charset_info;
   if (res)
@@ -881,6 +946,19 @@
       for (uint32_t j=0 ; j < key_info->key_parts ; j++,key_part++)
       {
         table->restoreRecordAsDefault();
+        table->setWriteSet(1);
+        table->setWriteSet(2);
+        table->setWriteSet(3);
+        table->setWriteSet(4);
+        table->setWriteSet(5);
+        table->setWriteSet(6);
+        table->setWriteSet(8);
+        table->setWriteSet(9);
+        table->setWriteSet(10);
+        table->setWriteSet(12);
+        table->setWriteSet(13);
+        table->setWriteSet(14);
+        table->setWriteSet(15);
         table->field[1]->store(db_name->str, db_name->length, cs);
         table->field[2]->store(table_name->str, table_name->length, cs);
         table->field[3]->store((int64_t) ((key_info->flags &
@@ -938,17 +1016,15 @@
           table->field[15]->store(key_info->comment.str,
                                   key_info->comment.length, cs);
         }
-        if (schema_table_store_record(session, table))
-        {
-          return (1);
-        }
+        store_table->addRow(table->record[0],
+                            table->s->reclength);
       }
     }
   }
-  return(res);
+  return res;
 }
 
-int StatusISMethods::fillTable(Session *session, TableList *tables, COND *)
+int StatusISMethods::fillTable(Session *session, TableList *tables)
 {
   LEX *lex= session->lex;
   const char *wild= lex->wild ? lex->wild->ptr() : NULL;
@@ -988,24 +1064,32 @@
   return(res);
 }
 
-static bool store_constraints(Session *session, Table *table, LEX_STRING *db_name,
+static bool store_constraints(Session *, Table *table, LEX_STRING *db_name,
                               LEX_STRING *table_name, const char *key_name,
                               uint32_t key_len, const char *con_type, uint32_t con_len)
 {
   const CHARSET_INFO * const cs= system_charset_info;
   table->restoreRecordAsDefault();
+  table->setWriteSet(1);
+  table->setWriteSet(2);
+  table->setWriteSet(3);
+  table->setWriteSet(4);
+  table->setWriteSet(5);
   table->field[1]->store(db_name->str, db_name->length, cs);
   table->field[2]->store(key_name, key_len, cs);
   table->field[3]->store(db_name->str, db_name->length, cs);
   table->field[4]->store(table_name->str, table_name->length, cs);
   table->field[5]->store(con_type, con_len, cs);
-  return schema_table_store_record(session, table);
+  TableList *tmp= table->pos_in_table_list;
+  tmp->schema_table->addRow(table->record[0], table->s->reclength);
+  return false;
 }
 
-int TabConstraintsISMethods::processTable(Session *session, TableList *tables,
+int TabConstraintsISMethods::processTable(plugin::InfoSchemaTable *, 
+                                          Session *session, TableList *tables,
                                           Table *table, bool res,
                                           LEX_STRING *db_name,
-                                          LEX_STRING *table_name) const
+                                          LEX_STRING *table_name)
 {
   if (res)
   {
@@ -1070,16 +1154,36 @@
   return (res);
 }
 
-int TablesISMethods::processTable(Session *session, TableList *tables,
-                                    Table *table, bool res,
-                                    LEX_STRING *db_name,
-                                    LEX_STRING *table_name) const
+int TablesISMethods::processTable(plugin::InfoSchemaTable *store_table, 
+                                  Session *session, TableList *tables,
+                                  Table *table, bool res,
+                                  LEX_STRING *db_name,
+                                  LEX_STRING *table_name)
 {
   const char *tmp_buff;
   DRIZZLE_TIME time;
   const CHARSET_INFO * const cs= system_charset_info;
 
   table->restoreRecordAsDefault();
+  table->setWriteSet(1);
+  table->setWriteSet(2);
+  table->setWriteSet(3);
+  table->setWriteSet(4);
+  table->setWriteSet(5);
+  table->setWriteSet(6);
+  table->setWriteSet(7);
+  table->setWriteSet(8);
+  table->setWriteSet(9);
+  table->setWriteSet(11);
+  table->setWriteSet(12);
+  table->setWriteSet(13);
+  table->setWriteSet(14);
+  table->setWriteSet(15);
+  table->setWriteSet(16);
+  table->setWriteSet(17);
+  table->setWriteSet(18);
+  table->setWriteSet(19);
+  table->setWriteSet(20);
   table->field[1]->store(db_name->str, db_name->length, cs);
   table->field[2]->store(table_name->str, table_name->length, cs);
   if (res)
@@ -1245,7 +1349,8 @@
       }
     }
   }
-  return (schema_table_store_record(session, table));
+  store_table->addRow(table->record[0], table->s->reclength);
+  return false;
 }
 
 
@@ -1291,7 +1396,7 @@
   return 0;
 }
 
-int VariablesISMethods::fillTable(Session *session, TableList *tables, COND *)
+int VariablesISMethods::fillTable(Session *session, TableList *tables)
 {
   int res= 0;
   LEX *lex= session->lex;
 
=== modified file 'plugin/info_schema/info_schema_methods.h'
--- plugin/info_schema/info_schema_methods.h	2009-09-25 20:13:37 +0000
+++ plugin/info_schema/info_schema_methods.h	2009-10-29 23:56:14 +0000
@@ -34,8 +34,7 @@
 {
 public:
   virtual int fillTable(Session *session, 
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
   virtual int oldFormat(Session *session,
                         drizzled::plugin::InfoSchemaTable *schema_table) const;
 };
@@ -50,8 +49,7 @@
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 /**
@@ -64,8 +62,7 @@
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 /**
@@ -90,9 +87,11 @@
 class KeyColUsageISMethods : public drizzled::plugin::InfoSchemaMethods
 {
 public:
-  virtual int processTable(Session *session, TableList *tables,
+  virtual int processTable(drizzled::plugin::InfoSchemaTable *store_table, 
+                           Session *session, 
+                           TableList *tables,
                            Table *table, bool res, LEX_STRING *db_name,
-                           LEX_STRING *table_name) const;
+                           LEX_STRING *table_name);
 };
 
 /**
@@ -105,8 +104,7 @@
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 /**
@@ -119,8 +117,7 @@
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 /**
@@ -133,8 +130,7 @@
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 /**
@@ -159,9 +155,10 @@
    *
    * @return 0 on success; 1 on failure
    */
-  virtual int processTable(Session *session, TableList *tables,
+  virtual int processTable(drizzled::plugin::InfoSchemaTable *store_table, 
+                           Session *session, TableList *tables,
                            Table *table, bool res, LEX_STRING *db_name,
-                           LEX_STRING *table_name) const;
+                           LEX_STRING *table_name);
 };
 
 /**
@@ -174,8 +171,7 @@
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
   virtual int oldFormat(Session *session,
                         drizzled::plugin::InfoSchemaTable *schema_table) const;
 };
@@ -189,9 +185,11 @@
 class StatsISMethods : public drizzled::plugin::InfoSchemaMethods
 {
 public:
-  virtual int processTable(Session *session, TableList *tables,
+  virtual int processTable(drizzled::plugin::InfoSchemaTable *store_table, 
+                           Session *session, 
+                           TableList *tables,
                            Table *table, bool res, LEX_STRING *db_name,
-                           LEX_STRING *table_name) const;
+                           LEX_STRING *table_name);
 };
 
 /**
@@ -204,8 +202,7 @@
 {
 public:
   virtual int fillTable(Session *session, 
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 /**
@@ -217,9 +214,10 @@
 class TabConstraintsISMethods : public drizzled::plugin::InfoSchemaMethods
 {
 public:
-  virtual int processTable(Session *session, TableList *tables,
+  virtual int processTable(drizzled::plugin::InfoSchemaTable *store_table, 
+                           Session *session, TableList *tables,
                            Table *table, bool res, LEX_STRING *db_name,
-                           LEX_STRING *table_name) const;
+                           LEX_STRING *table_name);
 };
 
 /**
@@ -231,9 +229,10 @@
 class TablesISMethods : public drizzled::plugin::InfoSchemaMethods
 {
 public:
-  virtual int processTable(Session *session, TableList *tables,
+  virtual int processTable(drizzled::plugin::InfoSchemaTable *store_table, 
+                           Session *session, TableList *tables,
                            Table *table, bool res, LEX_STRING *db_name,
-                           LEX_STRING *table_name) const;
+                           LEX_STRING *table_name);
 };
 
 /**
@@ -259,8 +258,7 @@
 {
 public:
   virtual int fillTable(Session *session, 
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 #endif /* PLUGIN_INFO_SCHEMA_INFO_SCHEMA_METHODS_H */
 
=== added directory 'plugin/info_schema_engine'
=== added file 'plugin/info_schema_engine/info_schema_cursor.cc'
--- plugin/info_schema_engine/info_schema_cursor.cc	1970-01-01 00:00:00 +0000
+++ plugin/info_schema_engine/info_schema_cursor.cc	2009-10-29 23:56:14 +0000
@@ -0,0 +1,144 @@
+/*
+ *  Copyright (C) 2009 Sun Microsystems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "drizzled/server_includes.h"
+#include "drizzled/join_table.h"
+#include "drizzled/session.h"
+#include "info_schema_cursor.h"
+#include "open_tables.h"
+
+#include <string>
+#include <map>
+
+using namespace std;
+using namespace drizzled;
+
+int InfoSchemaCursor::open(const char *name, int, uint32_t)
+{
+  string table_name(name);
+  string i_s_prefix("./information_schema/");
+  table_name.erase(0, i_s_prefix.length());
+
+  OpenTables &open_tables= OpenTables::singleton();
+  if (! (share= open_tables.getShare(table_name)))
+  {
+    return HA_ERR_OUT_OF_MEM;
+  }
+
+  assert(share);
+
+  thr_lock_data_init(share->getThreadLock(), &data_lock, NULL);
+
+  return 0;
+}
+
+int InfoSchemaCursor::close()
+{
+  OpenTables &open_tables= OpenTables::singleton();
+  open_tables.freeShare();
+  return 0;
+}
+
+int InfoSchemaCursor::info(uint32_t flags)
+{
+  /*
+   * If this flag is set, then we know that the time of the last
+   * modification needs to be modified. 
+   */
+  if (flags & HA_STATUS_TIME)
+  {
+  }
+
+  if (flags & HA_STATUS_VARIABLE)
+  {
+    stats.records= 1;
+  }
+
+  /*
+   * If this flag is set, then we know that the auto_increment value needs
+   * to be updated.
+   */
+  if (flags & HA_STATUS_AUTO)
+  {
+    stats.auto_increment_value= 1;
+  }
+
+  return 0;
+}
+
+int InfoSchemaCursor::rnd_init(bool)
+{
+  TableList *tmp= table->pos_in_table_list;
+  plugin::InfoSchemaTable *sch_table= share->getInfoSchemaTable();
+  if (sch_table)
+  {
+    sch_table->fillTable(ha_session(),
+                         tmp);
+    iter= sch_table->getRows().begin();
+  }
+  return 0;
+}
+
+int InfoSchemaCursor::rnd_next(unsigned char *buf)
+{
+  ha_statistic_increment(&SSV::ha_read_rnd_next_count);
+  plugin::InfoSchemaTable *sch_table= share->getInfoSchemaTable();
+  if (iter != sch_table->getRows().end() && 
+      ! sch_table->getRows().empty())
+  {
+    (*iter)->copyRecordInto(buf);
+    ++iter;
+    return 0;
+  }
+  sch_table->clearRows();
+  return HA_ERR_END_OF_FILE;
+}
+
+int InfoSchemaCursor::rnd_pos(unsigned char *, unsigned char *)
+{
+  ha_statistic_increment(&SSV::ha_read_rnd_count);
+  return HA_ERR_WRONG_COMMAND;
+}
+
+void InfoSchemaCursor::position(const unsigned char *)
+{
+  return;
+}
+
+THR_LOCK_DATA **InfoSchemaCursor::store_lock(Session *session,
+                                              THR_LOCK_DATA **to,
+                                              enum thr_lock_type lock_type)
+{
+  /* borrowed from archive and BDB engines. TODO: understand this! */
+  if (lock_type != TL_IGNORE && data_lock.type == TL_UNLOCK)
+  {
+    if ((lock_type >= TL_WRITE_CONCURRENT_INSERT && lock_type <= TL_WRITE) &&
+        ! session_tablespace_op(session))
+    {
+      lock_type= TL_WRITE_ALLOW_WRITE;
+    }
+    if (lock_type == TL_READ_NO_INSERT)
+    {
+      lock_type= TL_READ;
+    }
+    data_lock.type= lock_type;
+  }
+  *to++= &data_lock;
+  return to;
+}
+
 
=== added file 'plugin/info_schema_engine/info_schema_cursor.h'
--- plugin/info_schema_engine/info_schema_cursor.h	1970-01-01 00:00:00 +0000
+++ plugin/info_schema_engine/info_schema_cursor.h	2009-10-29 23:56:14 +0000
@@ -0,0 +1,175 @@
+/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2009 Sun Microsystems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_CURSOR_H
+#define DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_CURSOR_H
+
+#include <drizzled/cursor.h>
+#include <drizzled/show.h>
+#include <drizzled/plugin/info_schema_table.h>
+#include <mysys/thr_lock.h>
+
+/*
+ * Shared structure for correct LOCK operation
+ */
+class InfoSchemaShare
+{
+public:
+  InfoSchemaShare()
+    :
+      use_count(0),
+      lock(),
+      i_s_table(NULL)
+  {}
+
+  ~InfoSchemaShare()
+  {
+    thr_lock_delete(&lock);
+  }
+
+  uint32_t getUseCount() const
+  {
+    return use_count;
+  }
+
+  void incUseCount()
+  {
+    use_count++;
+  }
+
+  void decUseCount()
+  {
+    use_count--;
+  }
+
+  const std::string &getName() const
+  {
+    return i_s_table->getTableName();
+  }
+
+  void initThreadLock()
+  {
+    thr_lock_init(&lock);
+  }
+
+  THR_LOCK *getThreadLock()
+  {
+    return &lock;
+  }
+
+  void setInfoSchemaTable(const std::string &name)
+  {
+    i_s_table= drizzled::plugin::InfoSchemaTable::getTable(name.c_str());
+  }
+
+  drizzled::plugin::InfoSchemaTable *getInfoSchemaTable()
+  {
+    return i_s_table;
+  }
+
+
+private:
+
+  uint32_t use_count;
+  THR_LOCK lock;
+  drizzled::plugin::InfoSchemaTable *i_s_table;
+};
+
+class InfoSchemaCursor : public Cursor
+{
+public:
+
+  InfoSchemaCursor(drizzled::plugin::StorageEngine *engine_arg, TableShare *table_arg)
+    :
+      Cursor(engine_arg, table_arg)
+  {}
+
+  ~InfoSchemaCursor() {}
+
+  const char *table_type() const
+  {
+    return "INFORMATION_SCHEMA";
+  }
+
+  /*
+    The name of the index type that will be used for display
+    don't implement this method unless you really have indexes
+  */
+  const char *index_type(uint32_t)
+  {
+    return NULL;
+  }
+
+  uint64_t table_flags() const
+  {
+    return (HA_NULL_IN_KEY |
+            HA_CAN_INDEX_BLOBS |
+            HA_AUTO_PART_KEY);
+  }
+
+  uint32_t index_flags(uint32_t, uint32_t, bool) const
+  {
+    return 0;
+  }
+
+  /* open a table */
+  int open(const char *name, int mode, uint32_t test_if_locked);
+
+  /* close a table */
+  int close(void);
+
+  /* provide info to the optimizer */
+  int info(uint32_t flag);
+
+  /* preparation for table scan (is this true?) */
+  int rnd_init(bool scan);
+
+  /* get the next row and copy it into buf */
+  int rnd_next(unsigned char *buf);
+
+  /* locate row pointed to by pos, copy it into buf */
+  int rnd_pos(unsigned char *buf, unsigned char *pos);
+
+  /* record position of a record for reordering */
+  void position(const unsigned char *record);
+
+  /*
+   * @todo: return actual upper bound of number of records in the table.
+   * (e.g. save number of records seen on full table scan and/or use file size
+   * as upper bound)
+   */
+  ha_rows estimate_rows_upper_bound() 
+  { 
+    return HA_POS_ERROR; 
+  }
+
+  THR_LOCK_DATA **store_lock(Session *session,
+                             THR_LOCK_DATA **to,
+                             enum thr_lock_type lock_type);
+
+private:
+
+  THR_LOCK_DATA data_lock;
+  InfoSchemaShare *share;
+  drizzled::plugin::InfoSchemaTable::Rows::iterator iter;
+
+};
+
+#endif /* DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_CURSOR_H */
 
=== added file 'plugin/info_schema_engine/info_schema_engine.cc'
--- plugin/info_schema_engine/info_schema_engine.cc	1970-01-01 00:00:00 +0000
+++ plugin/info_schema_engine/info_schema_engine.cc	2009-10-29 23:56:14 +0000
@@ -0,0 +1,195 @@
+/*
+ *  Copyright (C) 2009 Sun Microsystems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <drizzled/server_includes.h>
+#include <drizzled/show.h>
+#include "info_schema_engine.h"
+#include "info_schema_cursor.h"
+#include "open_tables.h"
+
+#include <string>
+#include <map>
+
+using namespace std;
+using namespace drizzled;
+
+static const string engine_name("INFORMATION_SCHEMA");
+
+int InfoSchemaEngine::getTableProtoImplementation(const char *path,
+                                                  message::Table *table_proto)
+{
+  string table_name(path);
+  string i_s_prefix("./information_schema/");
+
+  if (table_name.compare(0, i_s_prefix.length(), i_s_prefix) != 0)
+  {
+    return ENOENT;
+  }
+
+  if (! table_proto)
+  {
+    return EEXIST;
+  }
+
+  table_name.erase(0, i_s_prefix.length());
+  plugin::InfoSchemaTable *schema_table= plugin::InfoSchemaTable::getTable(table_name.c_str());
+
+  if (! schema_table)
+  {
+    return ENOENT;
+  }
+
+  table_proto->set_name(table_name);
+  table_proto->set_type(message::Table::STANDARD);
+
+  message::Table::StorageEngine *protoengine= table_proto->mutable_engine();
+  protoengine->set_name(engine_name);
+
+  message::Table::TableOptions *table_options= table_proto->mutable_options();
+  table_options->set_collation_id(default_charset_info->number);
+  table_options->set_collation(default_charset_info->name);
+
+  const plugin::InfoSchemaTable::Columns &columns= schema_table->getColumns();
+  plugin::InfoSchemaTable::Columns::const_iterator iter= columns.begin();
+
+  while (iter != columns.end())
+  {
+    const plugin::ColumnInfo *column= *iter;
+    /* get the various proto variables we need */
+    message::Table::Field *proto_field= table_proto->add_field();
+    message::Table::Field::FieldOptions *field_options=
+      proto_field->mutable_options();
+    message::Table::Field::FieldConstraints *field_constraints=
+      proto_field->mutable_constraints();
+
+    proto_field->set_name(column->getName());
+    field_options->set_default_value("0");
+
+    if (column->getFlags() & MY_I_S_MAYBE_NULL)
+    {
+      field_options->set_default_null(true);
+      field_constraints->set_is_nullable(true);
+    }
+
+    if (column->getFlags() & MY_I_S_UNSIGNED)
+    {
+      field_constraints->set_is_unsigned(true);
+    }
+
+    switch(column->getType())
+    {
+    case DRIZZLE_TYPE_TINY:
+    case DRIZZLE_TYPE_LONG:
+      proto_field->set_type(message::Table::Field::INTEGER);
+      field_options->set_length(MAX_INT_WIDTH);
+      break;
+    case DRIZZLE_TYPE_DOUBLE:
+      proto_field->set_type(message::Table::Field::DOUBLE);
+      break;
+    case DRIZZLE_TYPE_NULL:
+      assert(true);
+      break;
+    case DRIZZLE_TYPE_TIMESTAMP:
+      proto_field->set_type(message::Table::Field::TIMESTAMP);
+      field_options->set_default_value("NOW()");
+      break;
+    case DRIZZLE_TYPE_LONGLONG:
+      proto_field->set_type(message::Table::Field::BIGINT);
+      field_options->set_length(MAX_BIGINT_WIDTH);
+      break;
+    case DRIZZLE_TYPE_DATETIME:
+      proto_field->set_type(message::Table::Field::DATETIME);
+      field_options->set_default_value("NOW()");
+      break;
+    case DRIZZLE_TYPE_DATE:
+      proto_field->set_type(message::Table::Field::DATE);
+      field_options->set_default_value("NOW()");
+      break;
+    case DRIZZLE_TYPE_VARCHAR:
+    {
+      message::Table::Field::StringFieldOptions *str_field_options=
+        proto_field->mutable_string_options();
+      proto_field->set_type(message::Table::Field::VARCHAR);
+      str_field_options->set_length(column->getLength());
+      field_options->set_length(column->getLength() * 4);
+      field_options->set_default_value("");
+      str_field_options->set_collation_id(default_charset_info->number);
+      str_field_options->set_collation(default_charset_info->name);
+      break;
+    }
+    case DRIZZLE_TYPE_NEWDECIMAL:
+    {
+      message::Table::Field::NumericFieldOptions *num_field_options=
+        proto_field->mutable_numeric_options();
+      proto_field->set_type(message::Table::Field::DECIMAL);
+      num_field_options->set_precision(column->getLength());
+      num_field_options->set_scale(column->getLength() % 10);
+      break;
+    }
+    default:
+      assert(true);
+      break;
+    }
+
+    ++iter;
+  }
+
+  return EEXIST;
+}
+
+static plugin::StorageEngine *info_schema_engine= NULL;
+
+static int init(plugin::Registry &registry)
+{
+  info_schema_engine= new(std::nothrow) InfoSchemaEngine(engine_name);
+  if (! info_schema_engine)
+  {
+    return true;
+  }
+
+  /* we are good to go */
+  registry.add(info_schema_engine);
+
+  return false;
+}
+
+static int deinit(plugin::Registry &registry)
+{
+  if (info_schema_engine)
+  {
+    registry.remove(info_schema_engine);
+    delete info_schema_engine;
+  }
+  return false;
+}
+
+drizzle_declare_plugin(info_schema_engine)
+{
+  "info_schema_engine",
+  "0.2",
+  "Padraig O'Sullivan",
+  "INFORMATION_SCHEMA Storage Engine",
+  PLUGIN_LICENSE_GPL,
+  init,   /* Plugin Init      */
+  deinit, /* Plugin Deinit    */
+  NULL,   /* status variables */
+  NULL,   /* system variables */
+  NULL    /* config options   */
+}
+drizzle_declare_plugin_end;
+
 
=== added file 'plugin/info_schema_engine/info_schema_engine.h'
--- plugin/info_schema_engine/info_schema_engine.h	1970-01-01 00:00:00 +0000
+++ plugin/info_schema_engine/info_schema_engine.h	2009-10-29 23:56:14 +0000
@@ -0,0 +1,91 @@
+/*
+ *  Copyright (C) 2009 Sun Microsystems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_H
+#define DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_H
+
+#include <drizzled/error.h>
+#include "info_schema_cursor.h"
+#include "table_name_iterator.h"
+
+#include <string>
+
+class InfoSchemaEngine : public drizzled::plugin::StorageEngine
+{
+public:
+
+  InfoSchemaEngine(const std::string &in_name)
+    :
+      drizzled::plugin::StorageEngine(in_name,
+                                      HTON_CREATE_NOT_SUPPORTED)
+  {}
+
+  ~InfoSchemaEngine() {}
+
+  virtual Cursor *create(TableShare *table,
+                          MEM_ROOT *mem_root)
+  {
+    return new(mem_root) InfoSchemaCursor(this, table);
+  }
+
+  const char **bas_ext() const
+  {
+    return NULL;
+  }
+
+  int createTableImplementation(Session *,
+                                const char *,
+                                Table *,
+                                HA_CREATE_INFO *,
+                                drizzled::message::Table *)
+  {
+    my_error(ER_ILLEGAL_HA_CREATE_OPTION,
+             MYF(0),
+             drizzled::plugin::StorageEngine::resolveName(this).c_str(),
+             "CREATE TABLE");
+    return -1;
+  }
+
+  int deleteTableImplementation(Session *,
+                                const std::string &table_path)
+  {
+    std::string i_s_prefix("./information_schema/");
+    if (table_path.compare(0, i_s_prefix.length(), i_s_prefix) == 0)
+    {
+      my_error(ER_DBACCESS_DENIED_ERROR,
+               MYF(0),
+               "",
+               "",
+               INFORMATION_SCHEMA_NAME.c_str());
+      return ER_DBACCESS_DENIED_ERROR;
+    }
+    return ENOENT;
+  }
+
+  int getTableProtoImplementation(const char *path,
+                                  drizzled::message::Table *table_proto);
+
+  drizzled::plugin::TableNameIteratorImplementation *tableNameIterator(const std::string &database)
+  {
+    return new InfoSchemaTableNameIterator(database);
+  }
+  
+
+};
+
+#endif /* DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_H */
 
=== added file 'plugin/info_schema_engine/open_tables.cc'
--- plugin/info_schema_engine/open_tables.cc	1970-01-01 00:00:00 +0000
+++ plugin/info_schema_engine/open_tables.cc	2009-10-29 23:56:14 +0000
@@ -0,0 +1,72 @@
+/*
+ *  Copyright (C) 2009 Sun Microsystems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <drizzled/server_includes.h>
+#include "info_schema_cursor.h"
+#include "open_tables.h"
+
+#include <string>
+#include <map>
+
+using namespace std;
+using namespace drizzled;
+
+InfoSchemaShare *OpenTables::getShare(const string &name)
+{
+  map<const string, InfoSchemaShare *>::iterator it;
+  pthread_mutex_lock(&mutex);
+
+  it= open_tables.find(name);
+  if (it != open_tables.end())
+  {
+    share= (*it).second;
+  }
+  else
+  {
+    share= NULL;
+  }
+
+  if (! share)
+  {
+    share= new(std::nothrow) InfoSchemaShare();
+    if (! share)
+    {
+      pthread_mutex_unlock(&mutex);
+      return NULL;
+    }
+    /* get the I_S table */
+    share->setInfoSchemaTable(name);
+    open_tables[name]= share;
+    share->initThreadLock();
+  }
+  share->incUseCount();
+  pthread_mutex_unlock(&mutex);
+
+  return share;
+}
+
+void OpenTables::freeShare()
+{
+  pthread_mutex_lock(&mutex);
+  share->decUseCount();
+  if (share->getUseCount() == 0)
+  {
+    open_tables.erase(share->getName());
+  }
+  pthread_mutex_unlock(&mutex);
+}
 
=== added file 'plugin/info_schema_engine/open_tables.h'
--- plugin/info_schema_engine/open_tables.h	1970-01-01 00:00:00 +0000
+++ plugin/info_schema_engine/open_tables.h	2009-10-29 23:56:14 +0000
@@ -0,0 +1,77 @@
+/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2009 Sun Microsystems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; version 2 of the License.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_OPEN_TABLES_H
+#define DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_OPEN_TABLES_H
+
+#include "info_schema_cursor.h"
+
+#include <string>
+#include <vector>
+#include <map>
+
+/**
+ * @class OpenTables
+ *
+ * Class which tracks all the open tables for the I_S storage engine.
+ * Encapsulating this functionality in a class will make it easier for us to
+ * change things such as whether a std::map or HASH is used to lookup the
+ * open tables.
+ */
+class OpenTables
+{
+public:
+
+  static OpenTables &singleton()
+  {
+    static OpenTables open_tabs;
+    return open_tabs;
+  }
+
+  InfoSchemaShare *getShare(const std::string &name);
+
+  void freeShare();
+
+private:
+
+  pthread_mutex_t mutex;
+
+  std::map<const std::string, InfoSchemaShare *>
+    open_tables;
+
+  InfoSchemaShare *share;
+
+  OpenTables()
+    :
+      mutex(),
+      open_tables(),
+      share(NULL)
+  {
+    pthread_mutex_init(&mutex, MY_MUTEX_INIT_FAST);
+  }
+
+  ~OpenTables()
+  {
+    pthread_mutex_destroy(&mutex);
+  }
+
+  OpenTables(const OpenTables&);
+};
+
+#endif /* DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_OPEN_TABLES_H */
 
=== added file 'plugin/info_schema_engine/plugin.ini'
--- plugin/info_schema_engine/plugin.ini	1970-01-01 00:00:00 +0000
+++ plugin/info_schema_engine/plugin.ini	2009-10-29 23:56:17 +0000
@@ -0,0 +1,9 @@
+[plugin]
+name=info_schema_engine
+title=INFORMATION_SCHEMA Storage Engine
+description=Engine for INFORMATION_SCHEMA tables
+sources=info_schema_engine.cc info_schema_cursor.cc open_tables.cc
+        table_name_iterator.cc
+headers=info_schema_engine.h info_schema_cursor.h open_tables.h
+        table_name_iterator.h
+load_by_default= yes
 
=== added file 'plugin/info_schema_engine/table_name_iterator.cc'
--- plugin/info_schema_engine/table_name_iterator.cc	1970-01-01 00:00:00 +0000
+++ plugin/info_schema_engine/table_name_iterator.cc	2009-10-29 23:56:17 +0000
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (C) 2009 Sun Microsystems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <drizzled/server_includes.h>
+#include <drizzled/plugin/info_schema_table.h>
+#include <drizzled/plugin/storage_engine.h>
+#include "table_name_iterator.h"
+
+#include <string>
+
+using namespace std;
+using namespace drizzled;
+
+int InfoSchemaTableNameIterator::next(string *name)
+{
+start:
+  if (iter == all_schema_tables.end())
+  {
+    return -1;
+  }
+
+  plugin::InfoSchemaTable *table= *iter;
+
+  if (table->isHidden())
+  {
+    ++iter;
+    goto start;
+  }
+
+  if (name)
+  {
+    name->assign(table->getTableName());
+  }
+
+  ++iter;
+
+  return 0;
+}
 
=== added file 'plugin/info_schema_engine/table_name_iterator.h'
--- plugin/info_schema_engine/table_name_iterator.h	1970-01-01 00:00:00 +0000
+++ plugin/info_schema_engine/table_name_iterator.h	2009-10-29 23:56:17 +0000
@@ -0,0 +1,61 @@
+/*
+ *  Copyright (C) 2009 Sun Microsystems
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_TABLE_NAME_ITERATOR_H
+#define DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_TABLE_NAME_ITERATOR_H
+
+#include <drizzled/plugin/info_schema_table.h>
+#include <drizzled/plugin/storage_engine.h>
+
+#include <vector>
+#include <string>
+
+class InfoSchemaTableNameIterator : public drizzled::plugin::TableNameIteratorImplementation
+{
+public:
+
+  InfoSchemaTableNameIterator(const std::string &database)
+    :
+      drizzled::plugin::TableNameIteratorImplementation(database)
+  {
+    /*
+     * If the database passed to the constructor is not the I_S database
+     * then we set the iterator to the end of the vector of schema tables to
+     * ensure that the next() method will not return any tables.
+     */
+    if (database.compare(INFORMATION_SCHEMA_NAME) == 0)
+    {
+      iter= drizzled::all_schema_tables.begin();
+    }
+    else
+    {
+      iter= drizzled::all_schema_tables.end();
+    }
+  }
+
+  ~InfoSchemaTableNameIterator() {}
+
+  int next(std::string *name);
+
+private:
+
+  std::vector<drizzled::plugin::InfoSchemaTable *>::iterator iter;
+
+};
+
+#endif /* DRIZZLE_PLUGIN_INFO_SCHEMA_ENGINE_TABLE_NAME_ITERATOR_H */
 
=== modified file 'plugin/innobase/handler/ha_innodb.cc'
--- plugin/innobase/handler/ha_innodb.cc	2009-10-16 10:27:33 +0000
+++ plugin/innobase/handler/ha_innodb.cc	2009-10-29 23:56:17 +0000
@@ -376,7 +376,7 @@
   UNIV_INTERN int renameTableImplementation(Session* session,
                                             const char* from, 
                                             const char* to);
-  UNIV_INTERN int deleteTableImplementation(Session* session, const string table_path);
+  UNIV_INTERN int deleteTableImplementation(Session* session, const string &table_path);
 };
 
 /** @brief Initialize the default value of innodb_commit_concurrency.
@@ -5959,7 +5959,7 @@
 InnobaseEngine::deleteTableImplementation(
 /*======================*/
         Session *session,
-	const string	table_path)	/* in: table name */
+	const string &table_path)	/* in: table name */
 {
 	int	error;
 	trx_t*	parent_trx;
 
=== modified file 'plugin/innobase/handler/i_s.cc'
--- plugin/innobase/handler/i_s.cc	2009-10-13 16:18:59 +0000
+++ plugin/innobase/handler/i_s.cc	2009-10-29 23:56:17 +0000
@@ -112,7 +112,6 @@
 */
 
 /* XXX these are defined in mysql_priv.h inside #ifdef DRIZZLE_SERVER */
-bool schema_table_store_record(Session *session, Table *table);
 void localtime_to_TIME(DRIZZLE_TIME *to, struct tm *from);
 
 /*******************************************************************//**
@@ -205,8 +204,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_TRX_STATE		1
         drizzled::plugin::ColumnInfo("trx_state",
@@ -214,8 +212,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_TRX_STARTED		2
         drizzled::plugin::ColumnInfo("trx_started",
@@ -223,8 +220,7 @@
                   DRIZZLE_TYPE_DATETIME,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_TRX_REQUESTED_LOCK_ID	3
         drizzled::plugin::ColumnInfo("trx_requested_lock_id",
@@ -232,8 +228,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   MY_I_S_MAYBE_NULL,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_TRX_WAIT_STARTED	4
         drizzled::plugin::ColumnInfo("trx_wait_started",
@@ -241,8 +236,7 @@
                   DRIZZLE_TYPE_DATETIME,
                   0,
                   MY_I_S_MAYBE_NULL,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_TRX_WEIGHT		5
         drizzled::plugin::ColumnInfo("trx_weight",
@@ -250,8 +244,7 @@
                   DRIZZLE_TYPE_LONGLONG,
                   0,
                   MY_I_S_UNSIGNED,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_TRX_DRIZZLE_THREAD_ID	6
         drizzled::plugin::ColumnInfo("trx_mysql_thread_id",
@@ -259,8 +252,7 @@
                   DRIZZLE_TYPE_LONGLONG,
                   0,
                   MY_I_S_UNSIGNED,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_TRX_QUERY		7
         drizzled::plugin::ColumnInfo("trx_query",
@@ -268,8 +260,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   MY_I_S_MAYBE_NULL,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
         drizzled::plugin::ColumnInfo()
 };
@@ -283,8 +274,6 @@
 fill_innodb_trx_from_cache(
 /*=======================*/
 	trx_i_s_cache_t*	cache,	/*!< in: cache to read from */
-	Session*		session,/*!< in: used to call
-					schema_table_store_record() */
 	Table*			table)	/*!< in/out: fill this table */
 {
 	Field**	fields;
@@ -351,7 +340,9 @@
 		OK(field_store_string(fields[IDX_TRX_QUERY],
 				      row->trx_query));
 
-		OK(schema_table_store_record(session, table));
+                TableList *tmp_list= table->pos_in_table_list;
+                tmp_list->schema_table->addRow(table->record[0],
+                                               table->s->reclength);
 	}
 
 	return(0);
@@ -383,8 +374,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_LOCK_TRX_ID		1
         drizzled::plugin::ColumnInfo("lock_trx_id",
@@ -392,8 +382,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_LOCK_MODE		2
         drizzled::plugin::ColumnInfo("lock_mode",
@@ -402,8 +391,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_LOCK_TYPE		3
         drizzled::plugin::ColumnInfo("lock_type",
@@ -411,8 +399,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_LOCK_TABLE		4
         drizzled::plugin::ColumnInfo("lock_table",
@@ -420,8 +407,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_LOCK_INDEX		5
         drizzled::plugin::ColumnInfo("lock_index",
@@ -429,8 +415,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   MY_I_S_MAYBE_NULL,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_LOCK_SPACE		6
         drizzled::plugin::ColumnInfo("lock_space",
@@ -438,8 +423,7 @@
                   DRIZZLE_TYPE_LONGLONG,
                   0,
                   MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_LOCK_PAGE		7
         drizzled::plugin::ColumnInfo("lock_page",
@@ -447,8 +431,7 @@
                   DRIZZLE_TYPE_LONGLONG,
                   0,
                   MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_LOCK_REC		8
         drizzled::plugin::ColumnInfo("lock_rec",
@@ -456,8 +439,7 @@
                   DRIZZLE_TYPE_LONGLONG,
                   0,
                   MY_I_S_UNSIGNED | MY_I_S_MAYBE_NULL,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_LOCK_DATA		9
         drizzled::plugin::ColumnInfo("lock_data",
@@ -465,8 +447,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   MY_I_S_MAYBE_NULL,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
         drizzled::plugin::ColumnInfo()
 };
@@ -571,7 +552,9 @@
 		OK(field_store_string(fields[IDX_LOCK_DATA],
 				      row->lock_data));
 
-		OK(schema_table_store_record(session, table));
+                TableList *tmp_list= table->pos_in_table_list;
+                tmp_list->schema_table->addRow(table->record[0],
+                                               table->s->reclength);
 	}
 
 	return(0);
@@ -603,8 +586,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_REQUESTED_LOCK_ID	1
         drizzled::plugin::ColumnInfo("requested_lock_id",
@@ -612,8 +594,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_BLOCKING_TRX_ID	2
         drizzled::plugin::ColumnInfo("blocking_trx_id",
@@ -621,8 +602,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
 #define IDX_BLOCKING_LOCK_ID	3
         drizzled::plugin::ColumnInfo("blocking_lock_id",
@@ -630,8 +610,7 @@
                   DRIZZLE_TYPE_VARCHAR,
                   0,
                   0,
-                  "",
-                  SKIP_OPEN_TABLE),
+                  ""),
 
         drizzled::plugin::ColumnInfo()
 };
@@ -645,8 +624,6 @@
 fill_innodb_lock_waits_from_cache(
 /*==============================*/
 	trx_i_s_cache_t*	cache,	/*!< in: cache to read from */
-	Session*		session,/*!< in: used to call
-					schema_table_store_record() */
 	Table*			table)	/*!< in/out: fill this table */
 {
 	Field**	fields;
@@ -699,7 +676,9 @@
 				   blocking_lock_id,
 				   sizeof(blocking_lock_id))));
 
-		OK(schema_table_store_record(session, table));
+                TableList *tmp_list= table->pos_in_table_list;
+                tmp_list->schema_table->addRow(table->record[0],
+                                               table->s->reclength);
 	}
 
 	return(0);
@@ -734,8 +713,7 @@
 TrxISMethods::fillTable(
 /*======================*/
 	Session*	session,/*!< in: thread */
-	TableList*	tables,	/*!< in/out: tables to fill */
-	COND*		)	/*!< in: condition (not used) */
+	TableList*	tables)	/*!< in/out: tables to fill */
 {
 	const char*		table_name;
 	int			ret;
@@ -771,7 +749,7 @@
 	if (innobase_strcasecmp(table_name, "innodb_trx") == 0) {
 
 		if (fill_innodb_trx_from_cache(
-			cache, session, tables->table) != 0) {
+			cache, tables->table) != 0) {
 
 			ret = 1;
 		}
@@ -787,7 +765,7 @@
 	} else if (innobase_strcasecmp(table_name, "innodb_lock_waits") == 0) {
 
 		if (fill_innodb_lock_waits_from_cache(
-			cache, session, tables->table) != 0) {
+			cache, tables->table) != 0) {
 
 			ret = 1;
 		}
@@ -826,48 +804,42 @@
                   DRIZZLE_TYPE_LONG,
                   0,
                   0,
-                  "Compressed Page Size",
-                  SKIP_OPEN_TABLE),
+                  "Compressed Page Size"),
 
         drizzled::plugin::ColumnInfo("compress_ops",
                   MY_INT32_NUM_DECIMAL_DIGITS,
                   DRIZZLE_TYPE_LONG,
                   0,
                   0,
-                  "Total Number of Compressions",
-                  SKIP_OPEN_TABLE),
+                  "Total Number of Compressions"),
 
         drizzled::plugin::ColumnInfo("compress_ops_ok",
                   MY_INT32_NUM_DECIMAL_DIGITS,
                   DRIZZLE_TYPE_LONG,
                   0,
                   0,
-                  "Total Number of Successful Compressions",
-                  SKIP_OPEN_TABLE),
+                  "Total Number of Successful Compressions"),
 
         drizzled::plugin::ColumnInfo("compress_time",
                   MY_INT32_NUM_DECIMAL_DIGITS,
                   DRIZZLE_TYPE_LONG,
                   0,
                   0,
-                  "Total Duration of Compressions in Seconds",
-                  SKIP_OPEN_TABLE),
+                  "Total Duration of Compressions in Seconds"),
 
         drizzled::plugin::ColumnInfo("uncompress_ops",
                   MY_INT32_NUM_DECIMAL_DIGITS,
                   DRIZZLE_TYPE_LONG,
                   0,
                   0,
-                  "Total Number of Decompressions",
-                  SKIP_OPEN_TABLE),
+                  "Total Number of Decompressions"),
 
         drizzled::plugin::ColumnInfo("uncompress_time",
                   MY_INT32_NUM_DECIMAL_DIGITS,
                   DRIZZLE_TYPE_LONG,
                   0,
                   0,
-                  "Total Duration of Decompressions in Seconds",
-                  SKIP_OPEN_TABLE),
+                  "Total Duration of Decompressions in Seconds"),
 
         drizzled::plugin::ColumnInfo()
 };
@@ -883,7 +855,6 @@
 /*=============*/
 	Session*	session,/*!< in: thread */
 	TableList*	tables,	/*!< in/out: tables to fill */
-	COND*		,	/*!< in: condition (ignored) */
 	ibool		reset)	/*!< in: TRUE=reset cumulated counts */
 {
 	Table*	table	= (Table *) tables->table;
@@ -915,10 +886,9 @@
 			memset(zip_stat, 0, sizeof *zip_stat);
 		}
 
-		if (schema_table_store_record(session, table)) {
-			status = 1;
-			break;
-		}
+                TableList *tmp_list= table->pos_in_table_list;
+                tmp_list->schema_table->addRow(table->record[0],
+                                               table->s->reclength);
 	}
 
 	return(status);
@@ -931,10 +901,9 @@
 CmpISMethods::fillTable(
 /*=========*/
 	Session*	session,/*!< in: thread */
-	TableList*	tables,	/*!< in/out: tables to fill */
-	COND*		cond)	/*!< in: condition (ignored) */
+	TableList*	tables)	/*!< in/out: tables to fill */
 {
-	return(i_s_cmp_fill_low(session, tables, cond, FALSE));
+	return(i_s_cmp_fill_low(session, tables, FALSE));
 }
 
 /*******************************************************************//**
@@ -944,10 +913,9 @@
 CmpResetISMethods::fillTable(
 /*===============*/
 	Session*	session,/*!< in: thread */
-	TableList*	tables,	/*!< in/out: tables to fill */
-	COND*		cond)	/*!< in: condition (ignored) */
+	TableList*	tables)	/*!< in/out: tables to fill */
 {
-	return(i_s_cmp_fill_low(session, tables, cond, TRUE));
+	return(i_s_cmp_fill_low(session, tables, TRUE));
 }
 
 /*******************************************************************//**
@@ -994,40 +962,35 @@
                   DRIZZLE_TYPE_LONG,
                   0,
                   0,
-                  "Buddy Block Size",
-                  SKIP_OPEN_TABLE),
+                  "Buddy Block Size"),
 
         drizzled::plugin::ColumnInfo("pages_used",
                   MY_INT32_NUM_DECIMAL_DIGITS,
                   DRIZZLE_TYPE_LONG,
                   0,
                   0,
-                  "Currently in Use",
-                  SKIP_OPEN_TABLE),
+                  "Currently in Use"),
 
         drizzled::plugin::ColumnInfo("pages_free",
                   MY_INT32_NUM_DECIMAL_DIGITS,
                   DRIZZLE_TYPE_LONG,
                   0,
                   0,
-                  "Currently Available",
-                  SKIP_OPEN_TABLE),
+                  "Currently Available"),
 
         drizzled::plugin::ColumnInfo("relocation_ops",
                   MY_INT64_NUM_DECIMAL_DIGITS,
                   DRIZZLE_TYPE_LONGLONG,
                   0,
                   0,
-                  "Total Number of Relocations",
-                  SKIP_OPEN_TABLE),
+                  "Total Number of Relocations"),
 
         drizzled::plugin::ColumnInfo("relocation_time",
                   MY_INT32_NUM_DECIMAL_DIGITS,
                   DRIZZLE_TYPE_LONG,
                   0,
                   0,
-                  "Total Duration of Relocations, in Seconds",
-                  SKIP_OPEN_TABLE),
+                  "Total Duration of Relocations, in Seconds"),
 
         drizzled::plugin::ColumnInfo()
 };
@@ -1042,7 +1005,6 @@
 /*================*/
 	Session*	session,/*!< in: thread */
 	TableList*	tables,	/*!< in/out: tables to fill */
-	COND*		,	/*!< in: condition (ignored) */
 	ibool		reset)	/*!< in: TRUE=reset cumulated counts */
 {
 	Table*	table	= (Table *) tables->table;
@@ -1070,10 +1032,9 @@
 			buddy_stat->relocated_usec = 0;
 		}
 
-		if (schema_table_store_record(session, table)) {
-			status = 1;
-			break;
-		}
+                TableList *tmp_list= table->pos_in_table_list;
+                tmp_list->schema_table->addRow(table->record[0],
+                                               table->s->reclength);
 	}
 
 	buf_pool_mutex_exit();
@@ -1087,10 +1048,9 @@
 CmpmemISMethods::fillTable(
 /*============*/
 	Session*	session,/*!< in: thread */
-	TableList*	tables,	/*!< in/out: tables to fill */
-	COND*		cond)	/*!< in: condition (ignored) */
+	TableList*	tables)	/*!< in/out: tables to fill */
 {
-	return(i_s_cmpmem_fill_low(session, tables, cond, FALSE));
+	return(i_s_cmpmem_fill_low(session, tables, FALSE));
 }
 
 /*******************************************************************//**
@@ -1100,10 +1060,9 @@
 CmpmemResetISMethods::fillTable(
 /*==================*/
 	Session*	session,/*!< in: thread */
-	TableList*	tables,	/*!< in/out: tables to fill */
-	COND*		cond)	/*!< in: condition (ignored) */
+	TableList*	tables)	/*!< in/out: tables to fill */
 {
-	return(i_s_cmpmem_fill_low(session, tables, cond, TRUE));
+	return(i_s_cmpmem_fill_low(session, tables, TRUE));
 }
 
 /*******************************************************************//**
 
=== modified file 'plugin/innobase/handler/i_s.h'
--- plugin/innobase/handler/i_s.h	2009-10-13 06:36:19 +0000
+++ plugin/innobase/handler/i_s.h	2009-10-29 23:56:17 +0000
@@ -30,48 +30,42 @@
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 class LocksISMethods : public drizzled::plugin::InfoSchemaMethods
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 class CmpISMethods : public drizzled::plugin::InfoSchemaMethods
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 class CmpResetISMethods : public drizzled::plugin::InfoSchemaMethods
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 class CmpmemISMethods : public drizzled::plugin::InfoSchemaMethods
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 class CmpmemResetISMethods : public drizzled::plugin::InfoSchemaMethods
 {
 public:
   virtual int fillTable(Session *session,
-                        TableList *tables,
-                        COND *cond);
+                        TableList *tables);
 };
 
 int i_s_common_deinit(drizzled::plugin::Registry &registry);
 
=== modified file 'plugin/memcached_stats/analysis_table.cc'
--- plugin/memcached_stats/analysis_table.cc	2009-10-03 17:20:06 +0000
+++ plugin/memcached_stats/analysis_table.cc	2009-10-29 23:56:17 +0000
@@ -42,9 +42,8 @@
 using namespace std;
 using namespace drizzled;
 
-int MemcachedAnalysisISMethods::fillTable(Session *session,
-                                          TableList *tables,
-                                          COND *)
+int MemcachedAnalysisISMethods::fillTable(Session *,
+                                          TableList *tables)
 {
   const CHARSET_INFO * const scs= system_charset_info;
   Table *table= tables->table;
@@ -88,10 +87,8 @@
     table->field[8]->store(report->pool_hit_ratio);
 
     /* store the actual record now */
-    if (schema_table_store_record(session, table))
-    {
-      return 1;
-    }
+    TableList *tmp_list= table->pos_in_table_list;
+    tmp_list->schema_table->addRow(table->record[0], table->s->reclength);
     free(report);
   }
 
@@ -110,8 +107,7 @@
                                                                DRIZZLE_TYPE_LONGLONG,
                                                                0,
                                                                0, 
-                                                               "Num of Servers Analyzed",
-                                                               SKIP_OPEN_TABLE);