← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/open_tables_state.h

  • Committer: Stewart Smith
  • Date: 2010-11-03 03:30:27 UTC
  • mto: (1902.1.1 build) (1910.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1903.
  • Revision ID: stewart@flamingspork.com-20101103033027-lskb6gxwwforfz71
fix docs warning: underline/overline too short for replace.rst

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/open_tables_state.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
21
21
#ifndef DRIZZLED_OPEN_TABLES_STATE_H
22
22
#define DRIZZLED_OPEN_TABLES_STATE_H
23
23
 
24
 
#include <drizzled/lock.h>
25
 
#include <drizzled/query_id.h>
 
24
#include "drizzled/lock.h"
26
25
 
27
26
namespace drizzled
28
27
{
29
28
 
30
 
class CachedDirectory;
31
 
 
32
29
/**
33
30
  Class that holds information about tables which were opened and locked
34
31
  by the thread. It is also used to save/restore this information in
51
48
    or for an intermediate table used in ALTER.
52
49
    XXX Why are internal temporary tables added to this list?
53
50
  */
54
 
private:
55
51
  Table *temporary_tables;
56
52
 
57
 
public:
58
 
 
59
 
  Table *getTemporaryTables()
60
 
  {
61
 
    return temporary_tables;
62
 
  }
63
 
 
64
 
  /**
65
 
    Mark all temporary tables which were used by the current statement or
66
 
    substatement as free for reuse, but only if the query_id can be cleared.
67
 
 
68
 
    @param session thread context
69
 
 
70
 
    @remark For temp tables associated with a open SQL HANDLER the query_id
71
 
            is not reset until the HANDLER is closed.
72
 
  */
73
 
  void mark_temp_tables_as_free_for_reuse();
74
 
 
75
 
protected:
76
 
  void close_temporary_tables();
77
 
 
78
 
public:
79
 
  void close_temporary_table(Table *table);
80
 
  
81
 
private:
82
 
  // The method below just handles the de-allocation of the table. In
83
 
  // a better memory type world, this would not be needed.
84
 
  void nukeTable(Table *table);
85
 
 
86
 
public:
87
 
  /* Work with temporary tables */
88
 
  Table *find_temporary_table(const identifier::Table &identifier);
89
 
 
90
 
  void dumpTemporaryTableNames(const char *id);
91
 
  int drop_temporary_table(const drizzled::identifier::Table &identifier);
92
 
  bool rm_temporary_table(plugin::StorageEngine *base, const identifier::Table &identifier);
93
 
  bool rm_temporary_table(const drizzled::identifier::Table &identifier, bool best_effort= false);
94
 
  Table *open_temporary_table(const drizzled::identifier::Table &identifier,
95
 
                              bool link_in_list= true);
96
 
 
97
 
  virtual query_id_t getQueryId()  const= 0;
98
 
 
99
 
private:
100
53
  Table *derived_tables;
101
 
public:
102
 
 
103
 
 
104
 
  Table *getDerivedTables()
105
 
  {
106
 
    return derived_tables;
107
 
  }
108
 
 
109
 
  void setDerivedTables(Table *arg)
110
 
  {
111
 
    derived_tables= arg;
112
 
  }
113
 
 
114
 
  void clearDerivedTables()
115
 
  {
116
 
    if (derived_tables)
117
 
      derived_tables= NULL; // They should all be invalid by this point
118
 
  }
119
 
 
120
54
  /*
121
55
    During a MySQL session, one can lock tables in two modes: automatic
122
56
    or manual. In automatic mode all necessary tables are locked just before
157
91
  { }
158
92
  virtual ~Open_tables_state() {}
159
93
 
160
 
  void doGetTableNames(CachedDirectory &directory,
161
 
                       const identifier::Schema &schema_identifier,
162
 
                       std::set<std::string>& set_of_names);
163
 
  void doGetTableNames(const identifier::Schema &schema_identifier,
164
 
                       std::set<std::string>& set_of_names);
165
 
 
166
 
  void doGetTableIdentifiers(CachedDirectory &directory,
167
 
                             const identifier::Schema &schema_identifier,
168
 
                             identifier::Table::vector &set_of_identifiers);
169
 
  void doGetTableIdentifiers(const identifier::Schema &schema_identifier,
170
 
                             identifier::Table::vector &set_of_identifiers);
171
 
 
172
 
  int doGetTableDefinition(const drizzled::identifier::Table &identifier,
173
 
                           message::Table &table_proto);
174
 
  bool doDoesTableExist(const drizzled::identifier::Table &identifier);
175
 
 
176
 
 
177
94
  Open_tables_state(uint64_t version_arg);
178
95
};
179
96