~stewart/drizzle/use-catalog-for-path

      result= session->reopen_tables();

 

      /* Set version for table */

      {

        /*

          Preserve the version (0) of write locked tables so that a impending

 

  (void)scopedLock;

 

 

  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());

  assert(table->key_read == 0);

  assert(!table->cursor || table->cursor->inited == Cursor::NONE);

 

 

  if (table->needs_reopen_or_name_lock() ||

  {

    table::remove_table(table);

    found_old_table= true;

 

  boost_unique_lock_t scoped_lock(table::Cache::singleton().mutex()); /* Close all open tables on Session */

 

  {

    found_old_table|= free_cached_table(scoped_lock);

  }

    Closing a MERGE child before the parent would be fatal if the

    other thread tries to abort the MERGE lock in between.

  */

  {

    Table *list= *prev;

 

{

  if (table->getShare()->getType())

  {

  }

  else

  {

    return true;

  }

  (*table)->open_placeholder= true;

 

  return false;

}

    TODO -> move this block into a separate function.

  */

  bool reset= false;

  {

    if (table->getShare()->getCacheKey() == key)

    {

 

      Note-> refresh_version is currently changed only during FLUSH TABLES.

    */

    {

    }

             ! (flags & DRIZZLE_LOCK_IGNORE_FLUSH))

    {

      /* Someone did a refresh while thread was opening tables */

          if (flags & DRIZZLE_LOCK_IGNORE_FLUSH)

          {

            /* Force close at once after usage */

            continue;

          }

 

              by other trying to take name-lock.

            */

            table->open_placeholder= true;

 

            return table ;

          }

 

    if (refresh)

    {

    }

    table->reginfo.lock_type= TL_READ; /* Assume read */

 

  }

 

  /* These variables are also set in reopen_table() */

  table->used_fields= 0;

  table->const_table= 0;

  table->null_row= false;

{

  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle()); /* Adjust locks at the end of ALTER TABLEL */

 

  {

    /*

      If we are not under LOCK TABLES we should have only one table

      open and locked so it makes sense to remove the lock at once.

    */

  }

 

  /*

    for target table name if we process ALTER Table ... RENAME.

    So loop below makes sense even if we are not under LOCK TABLES.

  */

  {

    if (table->getShare()->getCacheKey() == identifier.getKey())

    {

    DRIZZLE_LOCK_IGNORE_GLOBAL_READ_LOCK |

    DRIZZLE_LOCK_IGNORE_FLUSH;

 

    return false;

 

  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());

    */

    uint32_t opens= 0;

 

    {

      opens++;

    }

 

  tables_ptr =tables;

 

  {

    next= table->getNext();

 

{

  bool found= send_refresh;

 

 

  for (; table ; table=table->getNext())

  {

Table *drop_locked_tables(Session *session, const drizzled::identifier::Table &identifier)

{

  Table *table,*next,**prev, *found= 0;

 

  /*

    Note that we need to hold table::Cache::singleton().mutex() while changing the

    Closing a MERGE child before the parent would be fatal if the

    other thread tries to abort the MERGE lock in between.

  */

  {

    next=table->getNext();

    if (table->getShare()->getCacheKey() == identifier.getKey())

void abort_locked_tables(Session *session, const drizzled::identifier::Table &identifier)

{

  Table *table;

  {

    if (table->getShare()->getCacheKey() == identifier.getKey())

    {

  /* Also used for indicating that prelocking is need */

  bool safe_to_ignore_table;

 

restart:

  *counter= 0;

  set_proc_info("Opening tables");

  bool refresh;

 

  set_proc_info("Opening table");

  while (!(table= openTable(table_list, &refresh)) && refresh) ;

 

  if (table)

    table_list->lock_type= lock_type;

    table_list->table=     table;

 

    if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)

    {

        table= NULL;

    }

  }

  if (tables == NULL)

    return 0;

 

  Table **start,**ptr;

  uint32_t lock_flag= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN;

 

      *(ptr++)= table->table;

  }

 

  {

    return -1;

  }

#  Table object

*/

 

{

  assert(identifier.isTmp());

 

  if (link_in_list)

  {

    /* growing temp list at the head */

    if (new_tmp_table->getNext())

    {

      new_tmp_table->getNext()->setPrev(new_tmp_table);

    }

  }

  new_tmp_table->pos_in_table_list= 0;