← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/identifier/table.h

  • Committer: Monty Taylor
  • Date: 2008-09-16 00:00:48 UTC
  • mto: This revision was merged to the branch mainline in revision 391.
  • Revision ID: monty@inaugust.com-20080916000048-3rvrv3gv9l0ad3gs
Fixed copyright headers in drizzled/

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/identifier/table.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2010 Brian Aker
5
 
 *  Copyright (C) 2009 Sun Microsystems, Inc.
6
 
 *
7
 
 *  This program is free software; you can redistribute it and/or modify
8
 
 *  it under the terms of the GNU General Public License as published by
9
 
 *  the Free Software Foundation; either version 2 of the License, or
10
 
 *  (at your option) any later version.
11
 
 *
12
 
 *  This program is distributed in the hope that it will be useful,
13
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 *  GNU General Public License for more details.
16
 
 *
17
 
 *  You should have received a copy of the GNU General Public License
18
 
 *  along with this program; if not, write to the Free Software
19
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20
 
 */
21
 
 
22
 
/* 
23
 
  This is a "work in progress". The concept needs to be replicated throughout
24
 
  the code, but we will start with baby steps for the moment. To not incur
25
 
  cost until we are complete, for the moment it will do no allocation.
26
 
 
27
 
  This is mainly here so that it can be used in the SE interface for
28
 
  the time being.
29
 
 
30
 
  This will replace Table_ident.
31
 
  */
32
 
 
33
 
#ifndef DRIZZLED_IDENTIFIER_TABLE_H
34
 
#define DRIZZLED_IDENTIFIER_TABLE_H
35
 
 
36
 
#include <drizzled/enum.h>
37
 
#include "drizzled/definitions.h"
38
 
#include "drizzled/message/table.pb.h"
39
 
 
40
 
#include <string.h>
41
 
 
42
 
#include <assert.h>
43
 
 
44
 
#include <ostream>
45
 
#include <set>
46
 
#include <algorithm>
47
 
#include <functional>
48
 
 
49
 
#include <boost/functional/hash.hpp>
50
 
 
51
 
#include "drizzled/visibility.h"
52
 
 
53
 
namespace drizzled {
54
 
class Table;
55
 
 
56
 
namespace identifier {
57
 
 
58
 
class DRIZZLED_API Table : public Schema
59
 
{
60
 
public:
61
 
  typedef message::Table::TableType Type;
62
 
  typedef std::vector <Table> vector;
63
 
  typedef const Table& const_reference;
64
 
  typedef Table& reference;
65
 
 
66
 
  class Key
67
 
  {
68
 
    std::vector<char> key_buffer;
69
 
    size_t hash_value;
70
 
 
71
 
  public:
72
 
 
73
 
    Key() :
74
 
      hash_value(0)
75
 
    {
76
 
    }
77
 
 
78
 
    const char *vector() const
79
 
    {
80
 
      return &key_buffer[0];
81
 
    }
82
 
 
83
 
    std::vector<char> &vectorPtr()
84
 
    {
85
 
      return key_buffer;
86
 
    }
87
 
 
88
 
    void set(size_t resize_arg, const std::string &a, const std::string &b);
89
 
 
90
 
    friend bool operator==(const Key &left, const Key &right)
91
 
    {
92
 
      if (left.hash_value == right.hash_value and left.key_buffer.size() == right.key_buffer.size())
93
 
      {
94
 
        if (memcmp(&left.key_buffer[0], &right.key_buffer[0], left.key_buffer.size()) == 0)
95
 
          return true;
96
 
      }
97
 
 
98
 
      return false;
99
 
    }
100
 
 
101
 
    friend bool operator<(const Key &left, const Key &right)
102
 
    {
103
 
      return left.key_buffer < right.key_buffer;
104
 
    }
105
 
 
106
 
    size_t size() const
107
 
    {
108
 
      return key_buffer.size();
109
 
    }
110
 
 
111
 
    size_t getHashValue() const
112
 
    {
113
 
      return hash_value;
114
 
    }
115
 
  };
116
 
 
117
 
private:
118
 
 
119
 
  Type type;
120
 
  std::string path;
121
 
  std::string key_path;
122
 
  std::string table_name;
123
 
  Key key;
124
 
  size_t hash_value;
125
 
 
126
 
  void init();
127
 
 
128
 
  size_t getKeySize() const
129
 
  {
130
 
    return getSchemaName().size() + getTableName().size() + 2;
131
 
  }
132
 
 
133
 
public:
134
 
 
135
 
  Table(const drizzled::Table &table);
136
 
                   
137
 
  Table(const identifier::Schema &schema,
138
 
        const std::string &table_name_arg,
139
 
        Type tmp_arg= message::Table::STANDARD) :
140
 
    Schema(schema),
141
 
    type(tmp_arg),
142
 
    table_name(table_name_arg)
143
 
  { 
144
 
    init();
145
 
  }
146
 
 
147
 
  Table( const std::string &db_arg,
148
 
                   const std::string &table_name_arg,
149
 
                   Type tmp_arg= message::Table::STANDARD) :
150
 
    Schema(db_arg),
151
 
    type(tmp_arg),
152
 
    table_name(table_name_arg)
153
 
  { 
154
 
    init();
155
 
  }
156
 
 
157
 
  Table( const std::string &schema_name_arg,
158
 
                   const std::string &table_name_arg,
159
 
                   const std::string &path_arg ) :
160
 
    Schema(schema_name_arg),
161
 
    type(message::Table::TEMPORARY),
162
 
    path(path_arg),
163
 
    table_name(table_name_arg)
164
 
  { 
165
 
    init();
166
 
  }
167
 
 
168
 
  using Schema::compare;
169
 
 
170
 
  bool isTmp() const
171
 
  {
172
 
    if (type == message::Table::TEMPORARY || type == message::Table::INTERNAL)
173
 
      return true;
174
 
 
175
 
    return false;
176
 
  }
177
 
 
178
 
  static bool isView(message::Table::TableType arg) // Not a SQL view, but a view for I_S
179
 
  {
180
 
    switch (arg)
181
 
    {
182
 
    default:
183
 
    case message::Table::STANDARD:
184
 
    case message::Table::TEMPORARY:
185
 
    case message::Table::INTERNAL:
186
 
      break;
187
 
    case message::Table::FUNCTION:
188
 
      return true;
189
 
    }
190
 
 
191
 
    return false;
192
 
  }
193
 
 
194
 
  bool isView() const // Not a SQL view, but a view for I_S
195
 
  {
196
 
    return isView(type);
197
 
  }
198
 
 
199
 
  Type getType() const
200
 
  {
201
 
    return type;
202
 
  }
203
 
 
204
 
  virtual void getSQLPath(std::string &sql_path) const;
205
 
 
206
 
  virtual const std::string &getPath() const;
207
 
  const std::string &getKeyPath() const;
208
 
 
209
 
  void setPath(const std::string &new_path)
210
 
  {
211
 
    path= new_path;
212
 
  }
213
 
 
214
 
  const std::string &getTableName() const
215
 
  {
216
 
    return table_name;
217
 
  }
218
 
 
219
 
  void copyToTableMessage(message::Table &message) const;
220
 
 
221
 
  friend bool operator<(Table::const_reference left, Table::const_reference right)
222
 
  {
223
 
    if (left.getKey() < right.getKey())
224
 
    {
225
 
      return true;
226
 
    }
227
 
 
228
 
    return false;
229
 
  }
230
 
 
231
 
  friend bool operator==(Table::const_reference left, Table::const_reference right)
232
 
  {
233
 
    if (left.getHashValue() == right.getHashValue())
234
 
    {
235
 
      if (left.getKey() == right.getKey())
236
 
        return true;
237
 
    }
238
 
 
239
 
    return false;
240
 
  }
241
 
 
242
 
  static uint32_t filename_to_tablename(const char *from, char *to, uint32_t to_length);
243
 
  static size_t build_table_filename(std::string &path, const std::string &db, const std::string &table_name, bool is_tmp);
244
 
  static size_t build_tmptable_filename(std::string &buffer);
245
 
  static size_t build_tmptable_filename(std::vector<char> &buffer);
246
 
 
247
 
public:
248
 
  bool isValid() const;
249
 
 
250
 
  size_t getHashValue() const
251
 
  {
252
 
    return hash_value;
253
 
  }
254
 
 
255
 
  const Key &getKey() const
256
 
  {
257
 
    return key;
258
 
  }
259
 
};
260
 
 
261
 
std::ostream& operator<<(std::ostream& output, Table::const_reference identifier);
262
 
std::size_t hash_value(Table const& b);
263
 
std::size_t hash_value(Table::Key const& b);
264
 
 
265
 
} /* namespace identifier */
266
 
} /* namespace drizzled */
267
 
 
268
 
#endif /* DRIZZLED_IDENTIFIER_TABLE_H */