← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/session.cc

  • Committer: Brian Aker
  • Date: 2009-08-05 08:23:47 UTC
  • mfrom: (1109.1.6 merge)
  • Revision ID: brian@gaz-20090805082347-j2l9604jru68iu7s
Merge Brian

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/session.cc
26
26
#include <sys/stat.h>
27
27
#include <mysys/mysys_err.h>
28
28
#include <drizzled/error.h>
 
29
#include <drizzled/gettext.h>
29
30
#include <drizzled/query_id.h>
30
31
#include <drizzled/data_home.h>
31
32
#include <drizzled/sql_base.h>
1842
1843
  temporary_tables= NULL;
1843
1844
}
1844
1845
 
 
1846
/*
 
1847
  unlink from session->temporary tables and close temporary table
 
1848
*/
 
1849
 
 
1850
void Session::close_temporary_table(Table *table,
 
1851
                                    bool free_share, bool delete_table)
 
1852
{
 
1853
  if (table->prev)
 
1854
  {
 
1855
    table->prev->next= table->next;
 
1856
    if (table->prev->next)
 
1857
      table->next->prev= table->prev;
 
1858
  }
 
1859
  else
 
1860
  {
 
1861
    /* removing the item from the list */
 
1862
    assert(table == temporary_tables);
 
1863
    /*
 
1864
      slave must reset its temporary list pointer to zero to exclude
 
1865
      passing non-zero value to end_slave via rli->save_temporary_tables
 
1866
      when no temp tables opened, see an invariant below.
 
1867
    */
 
1868
    temporary_tables= table->next;
 
1869
    if (temporary_tables)
 
1870
      table->next->prev= NULL;
 
1871
  }
 
1872
  close_temporary(table, free_share, delete_table);
 
1873
}
 
1874
 
 
1875
/*
 
1876
  Close and delete a temporary table
 
1877
 
 
1878
  NOTE
 
1879
  This dosn't unlink table from session->temporary
 
1880
  If this is needed, use close_temporary_table()
 
1881
*/
 
1882
 
 
1883
void Session::close_temporary(Table *table, bool free_share, bool delete_table)
 
1884
{
 
1885
  StorageEngine *table_type= table->s->db_type();
 
1886
 
 
1887
  table->free_io_cache();
 
1888
  table->closefrm(false);
 
1889
 
 
1890
  if (delete_table)
 
1891
    rm_temporary_table(table_type, table->s->path.str);
 
1892
 
 
1893
  if (free_share)
 
1894
  {
 
1895
    table->s->free_table_share();
 
1896
    /* This makes me sad, but we're allocating it via malloc */
 
1897
    free(table);
 
1898
  }
 
1899
}
1845
1900
 
1846
1901
/** Clear most status variables. */
1847
1902
extern time_t flush_status_time;
2018
2073
  close_thread_tables();
2019
2074
}
2020
2075
 
2021
 
int Session::open_and_lock_tables(TableList *tables)
 
2076
bool Session::openTablesLock(TableList *tables)
2022
2077
{
2023
2078
  uint32_t counter;
2024
2079
  bool need_reopen;
2025
2080
 
2026
2081
  for ( ; ; )
2027
2082
  {
2028
 
    if (open_tables_from_list(&tables, &counter, 0))
2029
 
      return -1;
 
2083
    if (open_tables_from_list(&tables, &counter))
 
2084
      return true;
2030
2085
 
2031
 
    if (!lock_tables(this, tables, counter, &need_reopen))
 
2086
    if (!lock_tables(tables, counter, &need_reopen))
2032
2087
      break;
2033
2088
    if (!need_reopen)
2034
 
      return -1;
 
2089
      return true;
2035
2090
    close_tables_for_reopen(&tables);
2036
2091
  }
2037
2092
  if ((mysql_handle_derived(lex, &mysql_derived_prepare) ||
2038
2093
       (fill_derived_tables() &&
2039
2094
        mysql_handle_derived(lex, &mysql_derived_filling))))
2040
 
    return 1; /* purecov: inspected */
 
2095
    return true; /* purecov: inspected */
2041
2096
 
2042
 
  return 0;
 
2097
  return false;
2043
2098
}
2044
2099
 
2045
 
bool Session::open_normal_and_derived_tables(TableList *tables, uint32_t flags)
 
2100
bool Session::openTables(TableList *tables, uint32_t flags)
2046
2101
{
2047
2102
  uint32_t counter;
2048
2103
  bool ret= fill_derived_tables();
2052
2107
    return true; /* purecov: inspected */
2053
2108
  return false;
2054
2109
}
 
2110
 
 
2111
bool Session::rm_temporary_table(StorageEngine *base, char *path)
 
2112
{
 
2113
  bool error=0;
 
2114
 
 
2115
  assert(base);
 
2116
 
 
2117
  if (delete_table_proto_file(path))
 
2118
    error=1; /* purecov: inspected */
 
2119
 
 
2120
  if (base->deleteTable(this, path))
 
2121
  {
 
2122
    error=1;
 
2123
    errmsg_printf(ERRMSG_LVL_WARN, _("Could not remove temporary table: '%s', error: %d"),
 
2124
                  path, my_errno);
 
2125
  }
 
2126
  return(error);
 
2127
}
 
2128
 
 
2129