~drizzle-trunk/drizzle/development

 

 

/* Basic functions needed by many modules */

#include <assert.h>

 

#include <signal.h>

#  include <time.h>

# endif

#endif

 

#include <drizzled/sql_select.h>

#include <drizzled/error.h>

#include <drizzled/check_stack_overrun.h>

#include <drizzled/lock.h>

#include <drizzled/plugin/listen.h>

#include <drizzled/field/epoch.h>

#include <drizzled/field/null.h>

 

using namespace std;

 

    This has to be done to ensure that the table share is removed from

    the table defintion cache as soon as the last instance is removed

  */

  TableShare *share= new TableShare(identifier.getType(),

                                    identifier,

                                    const_cast<char *>(key.vector()),  static_cast<uint32_t>(table->getShare()->getCacheKeySize()));

 

  table->cursor->close();

  table->db_stat= 0;                            // Mark cursor closed

  table->setShare(share);

}

 

  if (sort.io_cache)

  {

    sort.io_cache->close_cached_file();

  }

}

 

  Session *session= this;

 

  {

 

    if (tables == NULL)

    {

      bool found= false;

      for (TableList *table= tables; table; table= table->next_local)

      {

        if (table::Cache::singleton().removeTable(session, identifier,

                                    RTFC_OWNED_BY_Session_FLAG))

        {

                                                     (table->open_placeholder && wait_for_placeholders)))

          {

            found= true;

            break;

          }

        }

        old locks. This should always succeed (unless some external process

        has removed the tables)

      */

 

      /* Set version for table */

      for (Table *table= session->open_tables; table ; table= table->getNext())

          table->getMutableShare()->refreshVersion();

      }

    }

  }

 

  if (wait_for_refresh)

  move one table to free list 

*/

 

{

  bool found_old_table= false;

  table::Concurrent *table= static_cast<table::Concurrent *>(open_tables);

 

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

 

  while (open_tables)

  {

  }

  some_tables_deleted= false;

 

{

  for (; table; table= table->*link )

  {

      break;

  }

  return table;

}

}

 

 

                                        std::set<std::string>& set_of_names)

{

  for (Table *table= getTemporaryTables() ; table ; table= table->getNext())

}

 

void Open_tables_state::doGetTableNames(CachedDirectory &,

                                        std::set<std::string> &set_of_names)

{

  doGetTableNames(schema_identifier, set_of_names);

}

 

{

  for (Table *table= getTemporaryTables() ; table ; table= table->getNext())

  {

    if (schema_identifier.compare(table->getShare()->getSchemaName()))

    {

                                                   table->getShare()->getTableName(),

                                                   table->getShare()->getPath()));

    }

}

 

void Open_tables_state::doGetTableIdentifiers(CachedDirectory &,

{

  doGetTableIdentifiers(schema_identifier, set_of_identifiers);

}

 

{

  for (Table *table= getTemporaryTables() ; table ; table= table->getNext())

  {

  return false;

}

 

{

  for (Table *table= getTemporaryTables() ; table ; table= table->getNext())

  {

    {

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

      {

 

        return EEXIST;

      }

  return ENOENT;

}

 

{

  for (Table *table= temporary_tables ; table ; table= table->getNext())

  {

  @retval -1  the table is in use by a outer query

*/

 

{

  Table *table;

 

 

void Session::unlink_open_table(Table *find)

{

  Table **prev;

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

 

  table that was locked with LOCK TABLES.

*/

 

{

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

  {

  case of failure.

*/

 

{

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

 

  /*

    Create a table entry with the right key and with an old refresh version

  */

  table::Placeholder *table= new table::Placeholder(this, identifier);

 

  if (not table::Cache::singleton().insert(table))

  {

 

    return NULL;

  }

  @retval  true   Error occured (OOM)

  @retval  false  Success. 'table' parameter set according to above rules.

*/

{

 

  boost_unique_lock_t scope_lock(table::Cache::singleton().mutex()); /* Obtain a name lock even though table is not in cache (like for create table)  */

 

  if (getKilled())

    return NULL;

 

  table::CacheRange ppp;

 

  /*

  {

    if (flags & DRIZZLE_OPEN_TEMPORARY_ONLY)

    {

      return NULL;

    }

 

    */

 

    {

 

      /*

        Actually try to find the table in the open_cache.

          /* Avoid self-deadlocks by detecting self-dependencies. */

          if (table->open_placeholder && table->in_use == this)

          {

            my_error(ER_UPDATE_TABLE_USED, MYF(0), table->getShare()->getTableName());

            return NULL;

          }