← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/open_tables_state.h

  • Committer: Lee Bieber
  • Date: 2010-11-12 19:03:08 UTC
  • mfrom: (1923.1.4 trunk)
  • Revision ID: kalebral@gmail.com-20101112190308-lyejhhgpfaf9r8f3
Merge Brian - Encapsulate up the cache we use in Session for tracking table proto for temp tables.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/open_tables_state.h
48
48
    or for an intermediate table used in ALTER.
49
49
    XXX Why are internal temporary tables added to this list?
50
50
  */
 
51
private:
51
52
  Table *temporary_tables;
52
 
 
 
53
public:
 
54
 
 
55
  Table *getTemporaryTables()
 
56
  {
 
57
    return temporary_tables;
 
58
  }
 
59
 
 
60
  /**
 
61
    Mark all temporary tables which were used by the current statement or
 
62
    substatement as free for reuse, but only if the query_id can be cleared.
 
63
 
 
64
    @param session thread context
 
65
 
 
66
    @remark For temp tables associated with a open SQL HANDLER the query_id
 
67
            is not reset until the HANDLER is closed.
 
68
  */
 
69
  void mark_temp_tables_as_free_for_reuse();
 
70
 
 
71
protected:
 
72
  void close_temporary_tables();
 
73
public:
 
74
  void close_temporary_table(Table *table);
 
75
  // The method below just handles the de-allocation of the table. In
 
76
  // a better memory type world, this would not be needed.
 
77
private:
 
78
  void nukeTable(Table *table);
 
79
public:
 
80
 
 
81
  /* Work with temporary tables */
 
82
  Table *find_temporary_table(const TableIdentifier &identifier);
 
83
 
 
84
  void dumpTemporaryTableNames(const char *id);
 
85
  int drop_temporary_table(const drizzled::TableIdentifier &identifier);
 
86
  bool rm_temporary_table(plugin::StorageEngine *base, TableIdentifier &identifier);
 
87
  bool rm_temporary_table(TableIdentifier &identifier, bool best_effort= false);
 
88
  Table *open_temporary_table(TableIdentifier &identifier,
 
89
                              bool link_in_list= true);
 
90
 
 
91
  virtual query_id_t getQueryId()  const= 0;
 
92
 
 
93
private:
53
94
  Table *derived_tables;
 
95
public:
 
96
 
 
97
 
 
98
  Table *getDerivedTables()
 
99
  {
 
100
    return derived_tables;
 
101
  }
 
102
 
 
103
  void setDerivedTables(Table *arg)
 
104
  {
 
105
    derived_tables= arg;
 
106
  }
 
107
 
 
108
  void clearDerivedTables()
 
109
  {
 
110
    if (derived_tables)
 
111
      derived_tables= NULL; // They should all be invalid by this point
 
112
  }
 
113
 
54
114
  /*
55
115
    During a MySQL session, one can lock tables in two modes: automatic
56
116
    or manual. In automatic mode all necessary tables are locked just before
91
151
  { }
92
152
  virtual ~Open_tables_state() {}
93
153
 
 
154
  void doGetTableNames(CachedDirectory &directory,
 
155
                       const SchemaIdentifier &schema_identifier,
 
156
                       std::set<std::string>& set_of_names);
 
157
  void doGetTableNames(const SchemaIdentifier &schema_identifier,
 
158
                       std::set<std::string>& set_of_names);
 
159
 
 
160
  void doGetTableIdentifiers(CachedDirectory &directory,
 
161
                             const SchemaIdentifier &schema_identifier,
 
162
                             TableIdentifiers &set_of_identifiers);
 
163
  void doGetTableIdentifiers(const SchemaIdentifier &schema_identifier,
 
164
                             TableIdentifiers &set_of_identifiers);
 
165
 
 
166
  int doGetTableDefinition(const drizzled::TableIdentifier &identifier,
 
167
                           message::Table &table_proto);
 
168
  bool doDoesTableExist(const drizzled::TableIdentifier &identifier);
 
169
 
 
170
 
94
171
  Open_tables_state(uint64_t version_arg);
95
172
};
96
173